Adds support for declaring the bundled name of a dts module export

Co-authored-by: Wesley Wigham <[email protected]>

Author: orta

src/compiler/checker.ts

@@ -4235,6 +4235,7 @@ namespace ts {
                         getProjectReferenceRedirect: fileName => host.getProjectReferenceRedirect(fileName),
                         isSourceOfProjectReferenceRedirect: fileName => host.isSourceOfProjectReferenceRedirect(fileName),
                         fileExists: fileName => host.fileExists(fileName),
+                        getCompilerOptions: () => host.getCompilerOptions()
                     } : undefined },
                     encounteredError: false,
                     visitedTypes: undefined,
@@ -5845,7 +5846,8 @@ namespace ts {
                                     const resolverHost = {
                                         getCanonicalFileName,
                                         getCurrentDirectory: () => context.tracker.moduleResolverHost!.getCurrentDirectory(),
-                                        getCommonSourceDirectory: () => context.tracker.moduleResolverHost!.getCommonSourceDirectory()
+                                        getCommonSourceDirectory: () => context.tracker.moduleResolverHost!.getCommonSourceDirectory(),
+                                        getCompilerOptions: () => context.tracker.moduleResolverHost!.getCompilerOptions()
                                     };
                                     const newName = getResolvedExternalModuleName(resolverHost, targetFile);
                                     return factory.createStringLiteral(newName);

src/compiler/commandLineParser.ts

@@ -986,6 +986,14 @@ namespace ts {
             category: Diagnostics.Advanced_Options,
             description: Diagnostics.Emit_class_fields_with_Define_instead_of_Set,
         },
+        {
+            name: "bundledPackageName",
+            type: "string",
+            affectsEmit: true,
+            category: Diagnostics.Advanced_Options,
+            description: Diagnostics.Provides_a_root_package_name_when_using_outFile_with_declarations,
+        },
+
         {
             name: "keyofStringsOnly",
             type: "boolean",

src/compiler/diagnosticMessages.json

@@ -1164,6 +1164,15 @@
         "category": "Error",
         "code": 1384
     },
+    "Provides a root package name when using outFile with declarations.": {
+        "category": "Message",
+        "code": 1385
+    },
+    "The `bundledPackageName` option must be provided when using outFile and node module resolution with declaration emit.": {
+        "category": "Error",
+        "code": 1386
+    },
+
 
     "The types of '{0}' are incompatible between these types.": {
         "category": "Error",

src/compiler/moduleSpecifiers.ts

@@ -117,7 +117,7 @@ namespace ts.moduleSpecifiers {
     }
 
     function getLocalModuleSpecifier(moduleFileName: string, { getCanonicalFileName, sourceDirectory }: Info, compilerOptions: CompilerOptions, { ending, relativePreference }: Preferences): string {
-        const { baseUrl, paths, rootDirs } = compilerOptions;
+        const { baseUrl, paths, rootDirs, bundledPackageName } = compilerOptions;
 
         const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) ||
             removeExtensionAndIndexPostFix(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions);
@@ -130,8 +130,9 @@ namespace ts.moduleSpecifiers {
             return relativePath;
         }
 
-        const importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions);
-        const fromPaths = paths && tryGetModuleNameFromPaths(removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths);
+        const bundledPkgName = bundledPackageName ? combinePaths(bundledPackageName, relativeToBaseUrl) : relativeToBaseUrl;
+        const importRelativeToBaseUrl = removeExtensionAndIndexPostFix(bundledPkgName, ending, compilerOptions);
+        const fromPaths = paths && tryGetModuleNameFromPaths(removeFileExtension(bundledPkgName), importRelativeToBaseUrl, paths);
         const nonRelative = fromPaths === undefined ? importRelativeToBaseUrl : fromPaths;
 
         if (relativePreference === RelativePreference.NonRelative) {
@@ -224,7 +225,7 @@ namespace ts.moduleSpecifiers {
             host,
             /*preferSymlinks*/ true,
             path => {
-                // dont return value, so we collect everything
+                // don't return value, so we collect everything
                 allFileNames.set(path, getCanonicalFileName(path));
                 importedFileFromNodeModules = importedFileFromNodeModules || pathContainsNodeModules(path);
             }

src/compiler/program.ts

@@ -3132,6 +3132,11 @@ namespace ts {
                 }
             }
 
+            // Without a package name you basically get a garbage bundled .d.ts file
+            if (outputFile && getEmitModuleResolutionKind(options) === ModuleResolutionKind.NodeJs && !options.bundledPackageName) {
+                createDiagnosticForOptionName(Diagnostics.The_bundledPackageName_option_must_be_provided_when_using_outFile_and_node_module_resolution_with_declaration_emit, options.out ? "out" : "outFile");
+            }
+
             if (options.resolveJsonModule) {
                 if (getEmitModuleResolutionKind(options) !== ModuleResolutionKind.NodeJs) {
                     createDiagnosticForOptionName(Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule");

src/compiler/types.ts

@@ -5642,6 +5642,7 @@ namespace ts {
         /** An error if set - this should only go through the -b pipeline and not actually be observed */
         /*@internal*/
         build?: boolean;
+        bundledPackageName?: string;
         charset?: string;
         checkJs?: boolean;
         /* @internal */ configFilePath?: string;
@@ -7746,6 +7747,7 @@ namespace ts {
         readonly redirectTargetsMap: RedirectTargetsMap;
         getProjectReferenceRedirect(fileName: string): string | undefined;
         isSourceOfProjectReferenceRedirect(fileName: string): boolean;
+        getCompilerOptions(): CompilerOptions;
     }
 
     // Note: this used to be deprecated in our public API, but is still used internally

src/compiler/utilities.ts

@@ -4010,6 +4010,7 @@ namespace ts {
         getCanonicalFileName(p: string): string;
         getCommonSourceDirectory(): string;
         getCurrentDirectory(): string;
+        getCompilerOptions(): CompilerOptions;
     }
 
     export function getResolvedExternalModuleName(host: ResolveModuleNameResolutionHost, file: SourceFile, referenceFile?: SourceFile): string {
@@ -4033,7 +4034,15 @@ namespace ts {
         const filePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
         const relativePath = getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
         const extensionless = removeFileExtension(relativePath);
-        return referencePath ? ensurePathIsNonModuleName(extensionless) : extensionless;
+        if (referencePath) {
+            return ensurePathIsNonModuleName(extensionless);
+        }
+        const rootPkgName = host.getCompilerOptions().bundledPackageName || "";
+        const newPath = combinePaths(rootPkgName, extensionless);
+        if (endsWith(newPath, "/index")) {
+            return newPath.slice(0, newPath.length - "/index".length);
+        }
+        return newPath;
     }
 
     export function getOwnEmitOutputFilePath(fileName: string, host: EmitHost, extension: string) {

src/services/utilities.ts

@@ -1737,6 +1737,7 @@ namespace ts {
             redirectTargetsMap: program.redirectTargetsMap,
             getProjectReferenceRedirect: fileName => program.getProjectReferenceRedirect(fileName),
             isSourceOfProjectReferenceRedirect: fileName => program.isSourceOfProjectReferenceRedirect(fileName),
+            getCompilerOptions: () => program.getCompilerOptions()
         };
     }
 

tests/baselines/reference/bundledNodeDTSFailsWithOutFlag.errors.txt

@@ -0,0 +1,29 @@
+error TS1386: The `bundledPackageName` option must be provided when using outFile and node module resolution with declaration emit.
+
+
+!!! error TS1386: The `bundledPackageName` option must be provided when using outFile and node module resolution with declaration emit.
+==== tests/cases/conformance/declarationEmit/index.ts (0 errors) ====
+    export * from "./nested";
+    
+==== tests/cases/conformance/declarationEmit/nested/base.ts (0 errors) ====
+    import { B } from "./shared";
+    
+    export function f() {
+        return new B();
+    }
+    
+==== tests/cases/conformance/declarationEmit/nested/derived.ts (0 errors) ====
+    import { f } from "./base";
+    
+    export function g() {
+        return f();
+    }
+    
+==== tests/cases/conformance/declarationEmit/nested/index.ts (0 errors) ====
+    export * from "./base";
+    export * from "./derived";
+    export * from "./shared";
+    
+==== tests/cases/conformance/declarationEmit/nested/shared.ts (0 errors) ====
+    export class B {}
+    

tests/baselines/reference/bundledNodeDTSFailsWithOutFlag.js

@@ -0,0 +1,50 @@
+//// [tests/cases/conformance/declarationEmit/bundledNodeDTSFailsWithOutFlag.ts] ////
+
+//// [index.ts]
+export * from "./nested";
+
+//// [base.ts]
+import { B } from "./shared";
+
+export function f() {
+    return new B();
+}
+
+//// [derived.ts]
+import { f } from "./base";
+
+export function g() {
+    return f();
+}
+
+//// [index.ts]
+export * from "./base";
+export * from "./derived";
+export * from "./shared";
+
+//// [shared.ts]
+export class B {}
+
+
+
+
+//// [out.d.ts]
+declare module "nested/shared" {
+    export class B {
+    }
+}
+declare module "nested/base" {
+    import { B } from "nested/shared";
+    export function f(): B;
+}
+declare module "nested/derived" {
+    export function g(): import("nested").B;
+}
+declare module "nested/index" {
+    export * from "nested/base";
+    export * from "nested/derived";
+    export * from "nested/shared";
+}
+declare module "index" {
+    export * from "nested/index";
+}