Declaration emit reveals paths within dependency that were not referred to in the source file

Context:

• Generating declaration files

Declaration emit reveals paths within dependency that were not referred to in the source file:

export declare const instance: import("dependency/internal-types").TheInterface;

This is a problem because changing paths within a dependency can break a dependent package.

TypeScript Version: 3.9.0-dev.20200212

Search Terms:

• inline import declaration
• declaration external relative path

Code

node_modules/@types/dependency/entrypoint.d.ts

import { TheInterface } from "./internal-types";
export { TheInterface };
export declare function getInstance(): TheInterface;

node_modules/@types/dependency/internal-types.d.ts

export interface TheInterface {}

node_modules/@types/dependency/index.d.ts

// empty - doesn't matter for this example

example.ts

import { getInstance } from "dependency/entrypoint";
export const instance = getInstance();

src/app/tsconfig.json

{
    "compilerOptions": {
        "declaration": true,
    }
}

Expected behavior:

example.d.ts

export declare const instance: import("dependency/entrypoint").TheInterface;

Actual behavior:

example.d.ts

export declare const instance: import("dependency/internal-types").TheInterface;

It seems that part of the solution could involve having the compiler avoid using relative paths in types (import("<relativepath>").<typename>) if the relativepath is outside the project.

Repro Repo: https://github.com/mheiber/repro-rel-import-inlining

Related Issues:

• Declaration emit should not inline type definitions - #37151
• Proposal: Bundling TS module type definitions - #4433

Issue written with the help of: @rricard, @robpalme and @mkubilayk

[remcohaszing]

This has gotten worse with the introduction of "moduleResolution": "node16". Paths are now rewritten to relative paths inside node_modules. (import('mdast-util-from-markdown') yields import("../../../node_modules/mdast-util-from-markdown/lib/index.js"))

https://github.com/remarkjs/remark/issues/1039#issuecomment-1239253894

[rricard]

When writing up that issue we also found out a pretty interesting effect.

If you were to move the internal-types.d.ts into a sub-directory in the dependency and have entrypoint load it:

node_modules/@types/dependency/entrypoint.d.ts

import { TheInterface } from "./int/internal-types";
export { TheInterface };
export declare function getInstance(): TheInterface;

We do get the wanted declaration output:

example.d.ts

export declare const instance: import("dependency/entrypoint").TheInterface;

This is great because that means that TypeScript has a notion of some files are meant to be imported and others do not.

At the moment it seems like everything in the root of the dependency is considered importable externally while subdirectories are not. Actually the rule seems to be, whoever is the least deep gets it:

checker.ts:5014

                    function sortByBestName(a: number, b: number) {
                        const specifierA = parentSpecifiers[a];
                        const specifierB = parentSpecifiers[b];
                        if (specifierA && specifierB) {
                            const isBRelative = pathIsRelative(specifierB);
                            if (pathIsRelative(specifierA) === isBRelative) {
                                // Both relative or both non-relative, sort by number of parts
                                return moduleSpecifiers.countPathComponents(specifierA) - moduleSpecifiers.countPathComponents(specifierB);
                            }
                            if (isBRelative) {
                                // A is non-relative, B is relative: prefer A
                                return -1;
                            }
                            // A is relative, B is non-relative: prefer B
                            return 1;
                        }
                        return 0;
                    }

#27340 / 7a71887c23a110009bc974f626245f03066e6926 by @weswigham

Is that behavior intentional, in which case we can use it as a workaround, or is this arbitrary behavior that can change?