fix(deps): correctly resolve root @types packages for dts deep imports (#852)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Kevin Deng <sxzz@sxzz.moe>

Author: 3 people

src/features/deps.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+import { getTypesPackageName, parseNodeModulesPath, parsePackageSpecifier } from './deps.ts'
+
+describe('parsePackageSpecifier', () => {
+  it('parses a simple package name', () => {
+    expect(parsePackageSpecifier('lodash')).toEqual(['lodash', ''])
+  })
+
+  it('parses a simple package with subpath', () => {
+    expect(parsePackageSpecifier('lodash/get')).toEqual(['lodash', '/get'])
+  })
+
+  it('parses a simple package with deep subpath', () => {
+    expect(parsePackageSpecifier('markdown-it/lib/token.mjs')).toEqual([
+      'markdown-it',
+      '/lib/token.mjs',
+    ])
+  })
+
+  it('parses a scoped package name', () => {
+    expect(parsePackageSpecifier('@scope/pkg')).toEqual(['@scope/pkg', ''])
+  })
+
+  it('parses a scoped package with subpath', () => {
+    expect(parsePackageSpecifier('@scope/pkg/subpath')).toEqual([
+      '@scope/pkg',
+      '/subpath',
+    ])
+  })
+})
+
+describe('parseNodeModulesPath', () => {
+  it('returns undefined for paths without node_modules', () => {
+    expect(parseNodeModulesPath('/project/project/src/index.ts')).toBeUndefined()
+  })
+
+  it('parses a simple package in node_modules', () => {
+    expect(parseNodeModulesPath('/project/node_modules/lodash/index.js')).toEqual([
+      'lodash',
+      '/index.js',
+      '/project/node_modules/lodash',
+    ])
+  })
+
+  it('parses a scoped package in node_modules', () => {
+    expect(
+      parseNodeModulesPath('/project/node_modules/@scope/pkg/dist/index.js'),
+    ).toEqual([
+      '@scope/pkg',
+      '/dist/index.js',
+      '/project/node_modules/@scope/pkg',
+    ])
+  })
+
+  it('uses the last node_modules segment for nested deps', () => {
+    expect(
+      parseNodeModulesPath('/project/node_modules/foo/node_modules/bar/lib/utils.js'),
+    ).toEqual([
+      'bar',
+      '/lib/utils.js',
+      '/project/node_modules/foo/node_modules/bar',
+    ])
+  })
+
+  it('handles package root without subpath', () => {
+    expect(parseNodeModulesPath('/project/node_modules/lodash')).toEqual([
+      'lodash',
+      '',
+      '/project/node_modules/lodash',
+    ])
+  })
+
+  it('normalizes backslashes on Windows-style paths', () => {
+    expect(
+      parseNodeModulesPath(String.raw`C:\project\node_modules\lodash\index.js`),
+    ).toEqual(['lodash', '/index.js', 'C:/project/node_modules/lodash'])
+  })
+})
+
+describe('getTypesPackageName', () => {
+  it('maps deep imports to the root DefinitelyTyped package', () => {
+    expect(getTypesPackageName('markdown-it/lib/token.mjs')).toBe(
+      '@types/markdown-it',
+    )
+  })
+
+  it('maps deep imports from scoped packages to the scoped DefinitelyTyped package', () => {
+    expect(getTypesPackageName('@scope/pkg/subpath')).toBe('@types/scope__pkg')
+  })
+})

src/features/deps.ts

@@ -218,7 +218,7 @@ export function DepsPlugin(
           if (chunk.type === 'asset') continue
 
           for (const id of chunk.moduleIds) {
-            const parsed = await parseBundledDep(id)
+            const parsed = await readBundledDepInfo(id)
             if (!parsed) continue
 
             deps.add(parsed.name)
@@ -314,13 +314,13 @@ export function DepsPlugin(
 
     if (deps) {
       if (deps.includes(id) || deps.some((dep) => id.startsWith(`${dep}/`))) {
-        const resolvedDep = await resolveDepPath(id, resolved)
+        const resolvedDep = await resolveDepSubpath(id, resolved)
         return resolvedDep ? [true, resolvedDep] : true
       }
 
       if (importer && RE_DTS.test(importer) && !id.startsWith('@types/')) {
-        const typesName = `@types/${id.replace(/^@/, '').replaceAll('/', '__')}`
-        if (deps.includes(typesName)) {
+        const typesName = getTypesPackageName(id)
+        if (typesName && deps.includes(typesName)) {
           return true
         }
       }
@@ -330,35 +330,35 @@ export function DepsPlugin(
   }
 }
 
-function parseDepPath(
+export function parsePackageSpecifier(id: string): [name: string, subpath: string] {
+  const [first, second] = id.split('/', 3)
+
+  const name = first[0] === '@' && second ? `${first}/${second}` : first
+  const subpath = id.slice(name.length)
+
+  return [name, subpath]
+}
+
+const NODE_MODULES = '/node_modules/'
+export function parseNodeModulesPath(
   id: string,
 ): [name: string, subpath: string, root: string] | undefined {
   const slashed = slash(id)
-  const lastNmIdx = slashed.lastIndexOf('/node_modules/')
+  const lastNmIdx = slashed.lastIndexOf(NODE_MODULES)
   if (lastNmIdx === -1) return
 
-  const afterNm = slashed.slice(lastNmIdx + 14 /* '/node_modules/'.length */)
-  const parts = afterNm.split('/')
+  const afterNm = slashed.slice(lastNmIdx + NODE_MODULES.length)
 
-  let name: string
-  if (parts[0][0] === '@') {
-    name = `${parts[0]}/${parts[1]}`
-  } else {
-    name = parts[0]
-  }
+  const [name, subpath] = parsePackageSpecifier(afterNm)
+  const root = slashed.slice(0, lastNmIdx + NODE_MODULES.length + name.length)
 
-  const root = slashed.slice(
-    0,
-    lastNmIdx + 14 /* '/node_modules/'.length */ + name.length,
-  )
-
-  return [name, afterNm.slice(name.length), root]
+  return [name, subpath, root]
 }
 
-async function parseBundledDep(
+async function readBundledDepInfo(
   moduleId: string,
 ): Promise<{ name: string; pkgName: string; version: string } | undefined> {
-  const parsed = parseDepPath(moduleId)
+  const parsed = parseNodeModulesPath(moduleId)
   if (!parsed) return
 
   const [name, , root] = parsed
@@ -371,7 +371,14 @@ async function parseBundledDep(
   } catch {}
 }
 
-async function resolveDepPath(id: string, resolved: ResolvedId | null) {
+export function getTypesPackageName(id: string): string | undefined {
+  const name = parsePackageSpecifier(id)[0]
+  if (!name) return
+
+  return `@types/${name.replace(/^@/, '').replace('/', '__')}`
+}
+
+async function resolveDepSubpath(id: string, resolved: ResolvedId | null) {
   if (!resolved?.packageJsonPath) return
 
   const parts = id.split('/')
@@ -390,7 +397,7 @@ async function resolveDepPath(id: string, resolved: ResolvedId | null) {
   // no `exports` field
   if (pkgJson.exports) return
 
-  const parsed = parseDepPath(resolved.id)
+  const parsed = parseNodeModulesPath(resolved.id)
   if (!parsed) return
 
   const result = parsed[0] + parsed[1]

tests/__snapshots__/externalize-deep-imports-covered-by-types-foo.snap.md

@@ -0,0 +1,19 @@
+## index.d.mts
+
+```mts
+import Token from "foo/lib/token.mjs";
+
+//#region node_modules/bar/types/index.d.ts
+interface AnchorOptions {
+  getTokensText?(tokens: Token[]): string;
+}
+//#endregion
+export { type AnchorOptions };
+```
+
+## index.mjs
+
+```mjs
+export {};
+
+```

tests/e2e.test.ts

@@ -881,6 +881,68 @@ test('externalize @types/foo', async (context) => {
   expect(fileMap['index.d.mts']).toContain('from "foo"')
 })
 
+test('externalize deep imports covered by @types/foo', async (context) => {
+  const node_modules = {
+    'node_modules/foo/index.js': `export default function foo() {}`,
+    'node_modules/foo/lib/token.mjs': `export default class Token {}`,
+    'node_modules/foo/package.json': JSON.stringify({
+      name: 'foo',
+      version: '1.0.0',
+      main: 'index.js',
+    }),
+
+    'node_modules/bar/index.js': `export default function bar() {}`,
+    'node_modules/bar/types/index.d.ts': `
+      import { default as Token } from 'foo/lib/token.mjs'
+
+      export interface AnchorOptions {
+        getTokensText?(tokens: Token[]): string
+      }
+
+      declare function bar(): void
+
+      export default bar
+    `,
+    'node_modules/bar/package.json': JSON.stringify({
+      name: 'bar',
+      version: '1.0.0',
+      main: 'index.js',
+      types: 'types/index.d.ts',
+    }),
+
+    'node_modules/@types/foo/index.d.ts': `export default interface Foo {}`,
+    'node_modules/@types/foo/lib/token.d.ts': `
+      export default class Token {
+        tag: string
+      }
+    `,
+    'node_modules/@types/foo/package.json': JSON.stringify({
+      name: '@types/foo',
+      version: '1.0.0',
+      types: 'index.d.ts',
+    }),
+  }
+
+  const { fileMap } = await testBuild({
+    context,
+    files: {
+      ...node_modules,
+      'index.ts': `export type { AnchorOptions } from 'bar'`,
+      'package.json': JSON.stringify({
+        name: 'test-pkg',
+        version: '1.0.0',
+        dependencies: {
+          '@types/foo': '^1.0.0',
+        },
+      }),
+    },
+    options: { dts: true },
+  })
+
+  expect(fileMap['index.d.mts']).toContain('from "foo/lib/token.mjs"')
+  expect(fileMap['index.d.mts']).not.toContain('class Token')
+})
+
 test('failOnWarn', async (context) => {
   const files = {
     'index.ts': `import 'unresolved'`,