typedoc 0.25.2 → 0.25.4

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,9 +452,10 @@ 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.
@@ -463,7 +465,12 @@ let Application = (() => {
                     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/declarationReference.js

@@ -9,20 +9,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDeclarationReference = exports.parseMeaning = exports.parseComponentPath = exports.parseComponent = exports.parseSymbolReference = exports.parseModuleSource = exports.parseString = exports.MeaningKeywords = void 0;
 exports.MeaningKeywords = [
-    "class",
-    "interface",
-    "type",
-    "enum",
-    "namespace",
-    "function",
-    "var",
-    "constructor",
-    "member",
-    "event",
-    "call",
-    "new",
-    "index",
-    "complex",
+    "class", // SymbolFlags.Class
+    "interface", // SymbolFlags.Interface
+    "type", // SymbolFlags.TypeAlias
+    "enum", // SymbolFlags.Enum
+    "namespace", // SymbolFlags.Module
+    "function", // SymbolFlags.Function
+    "var", // SymbolFlags.Variable
+    "constructor", // SymbolFlags.Constructor
+    "member", // SymbolFlags.ClassMember | SymbolFlags.EnumMember
+    "event", //
+    "call", // SymbolFlags.Signature (for __call)
+    "new", // SymbolFlags.Signature (for __new)
+    "index", // SymbolFlags.Signature (for __index)
+    "complex", // Any complex type
     // TypeDoc specific
     "getter",
     "setter",

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

@@ -121,13 +121,15 @@ function discoverComment(symbol, kind, logger, commentStyle) {
     // not the last one, since that will apply to the import or declaration.
     const reverse = !symbol.declarations?.some(typescript_1.default.isSourceFile);
     const discovered = [];
+    const seen = new Set();
     for (const decl of symbol.declarations || []) {
         const text = decl.getSourceFile().text;
         if (wantedKinds[kind].includes(decl.kind)) {
             const node = declarationToCommentNode(decl);
-            if (!node) {
+            if (!node || seen.has(node)) {
                 continue;
             }
+            seen.add(node);
             // Special behavior here! We temporarily put the implementation comment
             // on the reflection which contains all the signatures. This lets us pull
             // the comment on the implementation if some signature does not have a comment.

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

@@ -126,8 +126,8 @@ function blockTag(comment, lexer, config, warning) {
     (0, assert_1.ok)(blockTag.kind === lexer_1.TokenSyntaxKind.Tag, "blockTag called not at the start of a block tag."); // blockContent is broken if this fails.
     const tagName = aliasedTags.get(blockTag.text) || blockTag.text;
     let content;
-    if (tagName === "@example" && config.jsDocCompatibility.exampleTag) {
-        content = exampleBlockContent(comment, lexer, config, warning);
+    if (tagName === "@example") {
+        return exampleBlock(comment, lexer, config, warning);
     }
     else if (["@default", "@defaultValue"].includes(tagName) &&
         config.jsDocCompatibility.defaultTag) {
@@ -168,14 +168,59 @@ function defaultBlockContent(comment, lexer, config, warning) {
 /**
  * The `@example` tag gets a special case because otherwise we will produce many warnings
  * about unescaped/mismatched/missing braces in legacy JSDoc comments.
+ *
+ * In TSDoc, we also want to treat the first line of the block as the example name.
  */
-function exampleBlockContent(comment, lexer, config, warning) {
+function exampleBlock(comment, lexer, config, warning) {
     lexer.mark();
     const content = blockContent(comment, lexer, config, () => { });
     const end = lexer.done() || lexer.peek();
     lexer.release();
-    if (content.some((part) => part.kind === "code" && part.text.startsWith("```"))) {
-        return blockContent(comment, lexer, config, warning);
+    if (!config.jsDocCompatibility.exampleTag ||
+        content.some((part) => part.kind === "code" && part.text.startsWith("```"))) {
+        let exampleName = "";
+        // First line of @example block is the example name.
+        let warnedAboutRichNameContent = false;
+        outer: while ((lexer.done() || lexer.peek()) !== end) {
+            const next = lexer.peek();
+            switch (next.kind) {
+                case lexer_1.TokenSyntaxKind.NewLine:
+                    lexer.take();
+                    break outer;
+                case lexer_1.TokenSyntaxKind.Text: {
+                    const newline = next.text.indexOf("\n");
+                    if (newline !== -1) {
+                        exampleName += next.text.substring(0, newline);
+                        next.pos += newline + 1;
+                        break outer;
+                    }
+                    else {
+                        exampleName += lexer.take().text;
+                    }
+                    break;
+                }
+                case lexer_1.TokenSyntaxKind.Code:
+                case lexer_1.TokenSyntaxKind.Tag:
+                case lexer_1.TokenSyntaxKind.TypeAnnotation:
+                case lexer_1.TokenSyntaxKind.CloseBrace:
+                case lexer_1.TokenSyntaxKind.OpenBrace:
+                    if (!warnedAboutRichNameContent) {
+                        warning("The first line of an example tag will be taken literally as" +
+                            " the example name, and should only contain text.", lexer.peek());
+                        warnedAboutRichNameContent = true;
+                    }
+                    exampleName += lexer.take().text;
+                    break;
+                default:
+                    (0, utils_1.assertNever)(next.kind);
+            }
+        }
+        const content = blockContent(comment, lexer, config, warning);
+        const tag = new models_1.CommentTag("@example", content);
+        if (exampleName.trim()) {
+            tag.name = exampleName.trim();
+        }
+        return tag;
     }
     const tokens = [];
     while ((lexer.done() || lexer.peek()) !== end) {
@@ -187,24 +232,22 @@ function exampleBlockContent(comment, lexer, config, warning) {
         .trim();
     const caption = blockText.match(/^\s*<caption>(.*?)<\/caption>\s*(\n|$)/);
     if (caption) {
-        return [
-            {
-                kind: "text",
-                text: caption[1] + "\n",
-            },
+        const tag = new models_1.CommentTag("@example", [
             {
                 kind: "code",
                 text: makeCodeBlock(blockText.slice(caption[0].length)),
             },
-        ];
+        ]);
+        tag.name = caption[1];
+        return tag;
     }
     else {
-        return [
+        return new models_1.CommentTag("@example", [
             {
                 kind: "code",
                 text: makeCodeBlock(blockText),
             },
-        ];
+        ]);
     }
 }
 function blockContent(comment, lexer, config, warning) {

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/plugins/TypePlugin.js

@@ -156,7 +156,10 @@ let TypePlugin = (() => {
                 if (reflection.extendedBy) {
                     push(reflection.extendedBy);
                 }
-                reflection.typeHierarchy = root;
+                // No point setting up a hierarchy if there is no hierarchy to display
+                if (root.next) {
+                    reflection.typeHierarchy = root;
+                }
             });
         }
     };

package/dist/lib/converter/symbols.js

@@ -110,15 +110,6 @@ function convertSymbol(context, symbol, exportSymbol) {
         // { methodProperty() {} }
         flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Property);
     }
-    // A default exported function with no associated variable is a property, but
-    // we should really convert it as a variable for documentation purposes
-    // export default () => {}
-    // export default 123
-    if (flags === typescript_1.default.SymbolFlags.Property &&
-        symbol.name === "default" &&
-        context.scope.kindOf(models_1.ReflectionKind.Module | models_1.ReflectionKind.Project)) {
-        flags = typescript_1.default.SymbolFlags.BlockScopedVariable;
-    }
     for (const flag of (0, enum_1.getEnumFlags)(flags ^ allConverterFlags)) {
         if (!(flag & allConverterFlags)) {
             context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${typescript_1.default.SymbolFlags[flag]}`);
@@ -359,8 +350,15 @@ function convertClassOrInterface(context, symbol, exportSymbol) {
     convertConstructSignatures(reflectionContext, symbol);
     // And finally, index signatures
     (0, index_signature_1.convertIndexSignature)(reflectionContext, symbol);
+    // Normally this shouldn't matter, unless someone did something with skipLibCheck off.
+    return typescript_1.default.SymbolFlags.Alias;
 }
 function convertProperty(context, symbol, exportSymbol) {
+    // This might happen if we're converting a function-module created with Object.assign
+    // or `export default () => {}`
+    if (context.scope.kindOf(models_1.ReflectionKind.SomeModule | models_1.ReflectionKind.Project)) {
+        return convertVariable(context, symbol, exportSymbol);
+    }
     const declarations = symbol.getDeclarations() ?? [];
     // Don't do anything if we inherited this property and it is private.
     if (isInherited(context, symbol) &&
@@ -466,9 +464,10 @@ function createAlias(target, context, symbol, exportSymbol) {
 }
 function convertVariable(context, symbol, exportSymbol) {
     const declaration = symbol.getDeclarations()?.[0];
-    (0, assert_1.default)(declaration);
     const comment = context.getComment(symbol, models_1.ReflectionKind.Variable);
-    const type = context.checker.getTypeOfSymbolAtLocation(symbol, declaration);
+    const type = declaration
+        ? context.checker.getTypeOfSymbolAtLocation(symbol, declaration)
+        : context.checker.getTypeOfSymbol(symbol);
     if (isEnumLike(context.checker, type, declaration) &&
         comment?.hasModifier("@enum")) {
         return convertVariableAsEnum(context, symbol, exportSymbol);
@@ -481,7 +480,7 @@ function convertVariable(context, symbol, exportSymbol) {
     }
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Variable, symbol, exportSymbol);
     let typeNode;
-    if (typescript_1.default.isVariableDeclaration(declaration)) {
+    if (declaration && typescript_1.default.isVariableDeclaration(declaration)) {
         // Otherwise we might have destructuring
         typeNode = declaration.type;
     }
@@ -492,7 +491,7 @@ function convertVariable(context, symbol, exportSymbol) {
     return typescript_1.default.SymbolFlags.Property;
 }
 function isEnumLike(checker, type, location) {
-    if (!(0, enum_1.hasAllFlags)(type.flags, typescript_1.default.TypeFlags.Object)) {
+    if (!location || !(0, enum_1.hasAllFlags)(type.flags, typescript_1.default.TypeFlags.Object)) {
         return false;
     }
     return type.getProperties().every((prop) => {
@@ -545,6 +544,14 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     for (const signature of type.getCallSignatures()) {
         (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, signature, symbol);
     }
+    // #2436: Functions created with Object.assign on a function won't have a namespace flag
+    // but likely have properties that we should put into a namespace.
+    if (type.getProperties().length &&
+        !(0, enum_1.hasAnyFlag)(symbol.flags, typescript_1.default.SymbolFlags.NamespaceModule | typescript_1.default.SymbolFlags.ValueModule)) {
+        const ns = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
+        context.finalizeDeclarationReflection(ns);
+        convertSymbols(context.withScope(ns), type.getProperties());
+    }
     return typescript_1.default.SymbolFlags.Property;
 }
 function convertAccessor(context, symbol, exportSymbol) {
@@ -572,7 +579,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/converter/utils/repository.js

@@ -29,7 +29,7 @@ class AssumedRepository {
             path: fileName.substring(this.path.length + 1),
             line,
         };
-        return this.sourceLinkTemplate.replace(/\{(path|line)\}/g, (_, key) => replacements[key]);
+        return this.sourceLinkTemplate.replace(/\{(gitRevision|path|line)\}/g, (_, key) => replacements[key]);
     }
 }
 exports.AssumedRepository = AssumedRepository;
@@ -117,9 +117,9 @@ exports.GitRepository = GitRepository;
 // 3. project
 const repoExpressions = [
     /(github(?!.us)(?:\.[a-z]+)*\.[a-z]{2,})[:/]([^/]+)\/(.*)/,
-    /(\w+\.githubprivate.com)[:/]([^/]+)\/(.*)/,
-    /(\w+\.ghe.com)[:/]([^/]+)\/(.*)/,
-    /(\w+\.github.us)[:/]([^/]+)\/(.*)/,
+    /(\w+\.githubprivate.com)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(\w+\.ghe.com)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(\w+\.github.us)[:/]([^/]+)\/(.*)/, // GitHub enterprise
     /(bitbucket.org)[:/]([^/]+)\/(.*)/,
     /(gitlab.com)[:/]([^/]+)\/(.*)/,
 ];

package/dist/lib/converter/utils/symbols.js

@@ -6,8 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAliasedSymbol = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 function resolveAliasedSymbol(symbol, checker) {
+    const seen = new Set();
     while (typescript_1.default.SymbolFlags.Alias & symbol.flags) {
         symbol = checker.getAliasedSymbol(symbol);
+        // #2438, with declaration files, we might have an aliased symbol which eventually points to itself.
+        if (seen.has(symbol))
+            return symbol;
+        seen.add(symbol);
     }
     return symbol;
 }

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

@@ -17,8 +17,16 @@ export declare class ReflectionSymbolId {
     /**
      * Note: This is **not** serialized. It exists for sorting by declaration order, but
      * should not be needed when deserializing from JSON.
+     * Will be set to `Infinity` if the ID was deserialized from JSON.
      */
     pos: number;
+    /**
+     * Note: This is **not** serialized. It exists to support detection of the differences between
+     * symbols which share declarations, but are instantiated with different type parameters.
+     * This will be `NaN` if the symbol reference is not transient.
+     * Note: This can only be non-NaN if {@link pos} is finite.
+     */
+    transientId: number;
     constructor(symbol: ts.Symbol, declaration?: ts.Declaration);
     constructor(json: JSONOutput.ReflectionSymbolId);
     getStableKey(): ReflectionSymbolIdString;
@@ -27,3 +35,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,14 +3,16 @@ 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"));
 const fs_2 = require("../../utils/fs");
+const paths_1 = require("../../utils/paths");
 const tsutils_1 = require("../../utils/tsutils");
 const validation_1 = require("../../utils/validation");
-const paths_1 = require("../../utils/paths");
+let transientCount = 0;
+const transientIds = new WeakMap();
 /**
  * This exists so that TypeDoc can store a unique identifier for a `ts.Symbol` without
  * keeping a reference to the `ts.Symbol` itself. This identifier should be stable across
@@ -20,7 +22,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 = "";
             }
@@ -28,37 +30,43 @@ class ReflectionSymbolId {
                 this.qualifiedName = (0, tsutils_1.getQualifiedName)(symbol, symbol.name);
             }
             this.pos = declaration?.pos ?? Infinity;
+            if (symbol.flags & typescript_1.default.SymbolFlags.Transient) {
+                this.transientId = transientIds.get(symbol) ?? ++transientCount;
+                transientIds.set(symbol, this.transientId);
+            }
+            else {
+                this.transientId = NaN;
+            }
         }
         else {
             this.fileName = symbol.sourceFileName;
             this.qualifiedName = symbol.qualifiedName;
             this.pos = Infinity;
+            this.transientId = NaN;
         }
     }
     getStableKey() {
         if (Number.isFinite(this.pos)) {
-            return `${this.fileName}\0${this.qualifiedName}\0${this.pos}`;
+            return `${this.fileName}\0${this.qualifiedName}\0${this.pos}\0${this.transientId}`;
         }
         else {
             return `${this.fileName}\0${this.qualifiedName}`;
         }
     }
     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 +101,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, paths_1.normalizePath)((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;