Invalid synthesized import specifiers on infered types in declarations

[dmaretskyi]

🔎 Search Terms

"import specifiers in declarations", "import nested files"

🕗 Version & Regression Information

Can reproduce on version 5.2.2 and "next" (5.3.0-dev.20231030).

⏯ Playground Link

No response

💻 Code

// @file a.ts

import { forwardRef, type PropsWithChildren } from "react";

import { type ExportedType } from "@ts-bug/b";

export type Props = PropsWithChildren<{
  // Tile props.
  active?: ExportedType;
}>;

export const Component = forwardRef<HTMLLIElement, Props>(() => {
  return null;
});

// @file @ts-bug/src/index.ts

import { type ExportedType as NaturalExportedType } from './type'

export type ExportedType = NaturalExportedType;

// @file @ts-bug/src/type.ts

export type ExportedType = 'overlay' | 'rearrange' | 'origin' | 'destination';

🙁 Actual behavior

The generated declarations for a.ts contain an invalid import into one of the nested declaration files instead of using the main package export.

// @file a.d.ts

import { type PropsWithChildren } from "react";
import { type ExportedType } from "@ts-bug/b";
export type Props = PropsWithChildren<{
    active?: ExportedType;
}>;
export declare const Component: import("react").ForwardRefExoticComponent<{
    active?: import("b/dist/types/src/type").ExportedType | undefined;
} & {
    children?: import("react").ReactNode;
} & import("react").RefAttributes<HTMLLIElement>>;
//# sourceMappingURL=index.d.ts.map

🙂 Expected behavior

The declarations should use the main package export.

    active?: import("@ts-bug/b").ExportedType | undefined;

Additional information about the issue

Repoduction repo:
https://github.com/dmaretskyi/ts-bug

[dmaretskyi]

I'm suspecting this has something to do with how type-aliases are unwrapped during declaration generation: playground

export type Foo = 'a' | 'b'

export type Bar = Foo

const getX = (): Bar => 'a';

export const foo = () => {
    return getX()
}

// This generates:

export type Foo = 'a' | 'b';
export type Bar = Foo;
export declare const foo: () => Foo;

Notice that foo's return type was inferred as Foo instead of Bar that was explicitly specified in getX function. This is fine when all declarations are in one file, but could break if the aliases are spred out accross different files.

[sergiubologa]

We also encountered this issue in an Angular project. @RyanCavanaugh can you please prioritize it? Seems like a very important issue to me, since there's no workaround for it.

[sergiubologa]

Same issue is described here as well: nrwl/nx-examples#205