fix(deps): resolve subpath extensions for packages without exports field (#863)

Author: sxzz

dts.snapshot.json

@@ -103,7 +103,7 @@
     "ShebangPlugin": "declare function ShebangPlugin(_: Logger, _: string, _: string, _: boolean): Plugin",
     "WatchPlugin": "declare function WatchPlugin(_: string[], _: TsdownBundle): Plugin",
     "#exports": [
-      "DepPlugin",
+      "DepsPlugin",
       "NodeProtocolPlugin",
       "ReportPlugin",
       "ShebangPlugin",
@@ -124,8 +124,8 @@
     "CopyEntry": "interface CopyEntry {\n from: string | string[]\n to?: string\n flatten?: boolean\n verbose?: boolean\n rename?: string | ((_: string, _: string, _: string) => string)\n}",
     "CopyOptions": "type CopyOptions = Arrayable<string | CopyEntry>",
     "CopyOptionsFn": "type CopyOptionsFn = (_: ResolvedConfig) => Awaitable<CopyOptions>",
-    "DepPlugin": "declare function DepPlugin(_: ResolvedConfig, _: TsdownBundle): Plugin",
     "DepsConfig": "interface DepsConfig {\n neverBundle?: ExternalOption\n alwaysBundle?: Arrayable<string | RegExp> | NoExternalFn\n onlyBundle?: Arrayable<string | RegExp> | false\n onlyAllowBundle?: Arrayable<string | RegExp> | false\n skipNodeModulesBundle?: boolean\n}",
+    "DepsPlugin": "declare function DepsPlugin(_: ResolvedConfig, _: TsdownBundle): Plugin",
     "DevtoolsOptions": "interface DevtoolsOptions extends NonNullable<InputOptions['devtools']> {\n ui?: boolean | Partial<StartOptions>\n clean?: boolean\n}",
     "ExeOptions": "interface ExeOptions extends ExeExtensionOptions {\n seaConfig?: Omit<SeaConfig, 'main' | 'output' | 'mainFormat'>\n fileName?: string | ((_: RolldownChunk) => string)\n outDir?: string\n}",
     "ExportsOptions": "interface ExportsOptions {\n devExports?: boolean | string\n packageJson?: boolean\n all?: boolean\n exclude?: (RegExp | string)[]\n legacy?: boolean\n customExports?: Record<string, any> | ((_: Record<string, any>, _: { pkg: PackageJson; chunks: ChunksByFormat; isPublish: boolean }) => Awaitable<Record<string, any>>)\n inlinedDependencies?: boolean\n}",

package.json

@@ -142,7 +142,6 @@
   },
   "devDependencies": {
     "@arethetypeswrong/core": "catalog:peer",
-    "@publint/pack": "catalog:dev",
     "@sxzz/eslint-config": "catalog:dev",
     "@sxzz/prettier-config": "catalog:dev",
     "@sxzz/test-utils": "catalog:dev",

pnpm-lock.yaml

@@ -12,7 +12,6 @@ catalogs:
     '@clack/prompts': ^1.1.0
     giget: ^3.1.2
   dev:
-    '@publint/pack': ^0.1.4
     '@sxzz/eslint-config': ^7.8.3
     '@sxzz/prettier-config': ^2.3.1
     '@sxzz/test-utils': ^0.5.15

pnpm-workspace.yaml

@@ -18,14 +18,9 @@ import type { TsdownBundle } from '../utils/chunks.ts'
 import type { Logger } from '../utils/logger.ts'
 import type { Arrayable } from '../utils/types.ts'
 import type { PackageJson } from 'pkg-types'
-import type {
-  ExternalOption,
-  Plugin,
-  PluginContext,
-  ResolveIdExtraOptions,
-} from 'rolldown'
+import type { ExternalOption, Plugin, ResolvedId } from 'rolldown'
 
-const debug = createDebug('tsdown:dep')
+const debug = createDebug('tsdown:deps')
 
 export type NoExternalFn = (
   id: string,
@@ -162,37 +157,7 @@ export function resolveDepsConfig(
   }
 }
 
-async function parseBundledDep(
-  moduleId: string,
-): Promise<{ name: string; pkgName: string; version: string } | undefined> {
-  const slashed = slash(moduleId)
-  const lastNmIdx = slashed.lastIndexOf('/node_modules/')
-  if (lastNmIdx === -1) return
-
-  const afterNm = slashed.slice(lastNmIdx + 14 /* '/node_modules/'.length */)
-  const parts = afterNm.split('/')
-
-  let name: string
-  if (parts[0][0] === '@') {
-    name = `${parts[0]}/${parts[1]}`
-  } else {
-    name = parts[0]
-  }
-
-  const root = slashed.slice(
-    0,
-    lastNmIdx + 14 /* '/node_modules/'.length */ + name.length,
-  )
-
-  try {
-    const json = JSON.parse(
-      await readFile(path.join(root, 'package.json'), 'utf8'),
-    )
-    return { name, pkgName: json.name, version: json.version }
-  } catch {}
-}
-
-export function DepPlugin(
+export function DepsPlugin(
   {
     pkg,
     deps: { alwaysBundle, onlyBundle, skipNodeModulesBundle },
@@ -204,28 +169,40 @@ export function DepPlugin(
   const deps = pkg && Array.from(getProductionDeps(pkg))
 
   return {
-    name: 'tsdown:external',
+    name: 'tsdown:deps',
     resolveId: {
       filter: [include(and(id(/^[^.]/), importerId(/./)))],
       async handler(id, importer, extraOptions) {
         if (extraOptions.isEntry) return
         typeAssert(importer)
 
-        const shouldExternal = await externalStrategy(
-          this,
-          id,
-          importer,
-          extraOptions,
-        )
+        const resolved = await this.resolve(id, importer, {
+          ...extraOptions,
+          skipSelf: true,
+        })
+        let shouldExternal = await externalStrategy(id, importer, resolved)
+        if (Array.isArray(shouldExternal)) {
+          debug('custom resolved id for %o -> %o', id, shouldExternal[1])
+          id = shouldExternal[1]
+          shouldExternal = shouldExternal[0]
+        }
         const nodeBuiltinModule = isBuiltin(id)
+        const moduleSideEffects = nodeBuiltinModule ? false : undefined
 
         debug('shouldExternal: %o = %o', id, shouldExternal)
 
         if (shouldExternal === true || shouldExternal === 'absolute') {
           return {
             id,
             external: shouldExternal,
-            moduleSideEffects: nodeBuiltinModule ? false : undefined,
+            moduleSideEffects,
+          }
+        }
+
+        if (resolved) {
+          return {
+            ...resolved,
+            moduleSideEffects,
           }
         }
       },
@@ -311,35 +288,34 @@ export function DepPlugin(
 
   /**
    * - `true`: always external
+   * - `[true, resolvedId]`: external with custom resolved ID
    * - `false`: skip, let other plugins handle it
    * - `'absolute'`: external as absolute path
    * - `'no-external'`: skip, but mark as non-external for inlineOnly check
    */
   async function externalStrategy(
-    context: PluginContext,
     id: string,
     importer: string | undefined,
-    extraOptions: ResolveIdExtraOptions,
-  ): Promise<boolean | 'absolute' | 'no-external'> {
+    resolved: ResolvedId | null,
+  ): Promise<boolean | [true, string] | 'absolute' | 'no-external'> {
     if (id === shimFile) return false
 
     if (alwaysBundle?.(id, importer)) {
       return 'no-external'
     }
 
-    if (skipNodeModulesBundle) {
-      const resolved = await context.resolve(id, importer, extraOptions)
-      if (
-        resolved &&
-        (resolved.external || RE_NODE_MODULES.test(resolved.id))
-      ) {
-        return true
-      }
+    if (
+      skipNodeModulesBundle &&
+      resolved &&
+      (resolved.external || RE_NODE_MODULES.test(resolved.id))
+    ) {
+      return true
     }
 
     if (deps) {
       if (deps.includes(id) || deps.some((dep) => id.startsWith(`${dep}/`))) {
-        return true
+        const resolvedDep = await resolveDepPath(id, resolved)
+        return resolvedDep ? [true, resolvedDep] : true
       }
 
       if (importer && RE_DTS.test(importer) && !id.startsWith('@types/')) {
@@ -354,6 +330,75 @@ export function DepPlugin(
   }
 }
 
+function parseDepPath(
+  id: string,
+): [name: string, subpath: string, root: string] | undefined {
+  const slashed = slash(id)
+  const lastNmIdx = slashed.lastIndexOf('/node_modules/')
+  if (lastNmIdx === -1) return
+
+  const afterNm = slashed.slice(lastNmIdx + 14 /* '/node_modules/'.length */)
+  const parts = afterNm.split('/')
+
+  let name: string
+  if (parts[0][0] === '@') {
+    name = `${parts[0]}/${parts[1]}`
+  } else {
+    name = parts[0]
+  }
+
+  const root = slashed.slice(
+    0,
+    lastNmIdx + 14 /* '/node_modules/'.length */ + name.length,
+  )
+
+  return [name, afterNm.slice(name.length), root]
+}
+
+async function parseBundledDep(
+  moduleId: string,
+): Promise<{ name: string; pkgName: string; version: string } | undefined> {
+  const parsed = parseDepPath(moduleId)
+  if (!parsed) return
+
+  const [name, , root] = parsed
+
+  try {
+    const json = JSON.parse(
+      await readFile(path.join(root, 'package.json'), 'utf8'),
+    )
+    return { name, pkgName: json.name, version: json.version }
+  } catch {}
+}
+
+async function resolveDepPath(id: string, resolved: ResolvedId | null) {
+  if (!resolved?.packageJsonPath) return
+
+  const parts = id.split('/')
+  // ignore scope
+  if (parts[0][0] === '@') parts.shift()
+  // ignore no subpath or file imports
+  if (parts.length === 1 || parts.at(-1)!.includes('.')) return
+
+  let pkgJson: Record<string, any>
+  try {
+    pkgJson = JSON.parse(await readFile(resolved.packageJsonPath, 'utf8'))
+  } catch {
+    return
+  }
+
+  // no `exports` field
+  if (pkgJson.exports) return
+
+  const parsed = parseDepPath(resolved.id)
+  if (!parsed) return
+
+  const result = parsed[0] + parsed[1]
+  if (result === id) return
+
+  return result
+}
+
 /*
  * Production deps should be excluded from the bundle
  */

src/features/deps.ts

@@ -16,7 +16,7 @@ import pkg from '../../package.json' with { type: 'json' }
 import { mergeUserOptions } from '../config/options.ts'
 import { importWithError, pkgExists } from '../utils/general.ts'
 import { LogLevels } from '../utils/logger.ts'
-import { DepPlugin } from './deps.ts'
+import { DepsPlugin } from './deps.ts'
 import { NodeProtocolPlugin } from './node-protocol.ts'
 import { resolveChunkAddon, resolveChunkFilename } from './output.ts'
 import { ReportPlugin } from './report.ts'
@@ -112,7 +112,7 @@ async function resolveInputOptions(
   }
 
   if (config.pkg || config.deps.skipNodeModulesBundle) {
-    plugins.push(DepPlugin(config, bundle))
+    plugins.push(DepsPlugin(config, bundle))
   }
 
   if (dts) {

src/features/rolldown.ts

@@ -1,4 +1,4 @@
-export { DepPlugin } from './features/deps.ts'
+export { DepsPlugin } from './features/deps.ts'
 export { NodeProtocolPlugin } from './features/node-protocol.ts'
 export { ReportPlugin } from './features/report.ts'
 export { ShebangPlugin } from './features/shebang.ts'

src/plugins.ts

@@ -0,0 +1,7 @@
+## index.mjs
+
+```mjs
+import { lt } from "my-dep/functions/lt.js";
+export { lt };
+
+```

tests/__snapshots__/resolve-dep-subpath-without-exports-field/dep-file-should-resolve-to-dep-file-js.snap.md

@@ -0,0 +1,7 @@
+## index.mjs
+
+```mjs
+import { folder } from "my-dep/folder/index.js";
+export { folder };
+
+```

tests/__snapshots__/resolve-dep-subpath-without-exports-field/dep-folder-should-resolve-to-dep-folder-index-js.snap.md

@@ -897,6 +897,62 @@ test('failOnWarn', async (context) => {
   ).rejects.toThrow('Module not found')
 })
 
+describe('resolve dep subpath without exports field', () => {
+  test('dep/file should resolve to dep/file.js', async (context) => {
+    const node_modules = {
+      'node_modules/my-dep/package.json': JSON.stringify({
+        name: 'my-dep',
+        version: '1.0.0',
+        main: 'index.js',
+      }),
+      'node_modules/my-dep/index.js': `export const main = 1`,
+      'node_modules/my-dep/functions/lt.js': `export const lt = () => {}`,
+    }
+
+    const { fileMap } = await testBuild({
+      context,
+      files: {
+        ...node_modules,
+        'index.ts': `export { lt } from 'my-dep/functions/lt'`,
+        'package.json': JSON.stringify({
+          name: 'test-pkg',
+          version: '1.0.0',
+          dependencies: { 'my-dep': '^1.0.0' },
+        }),
+      },
+    })
+
+    expect(fileMap['index.mjs']).toContain('my-dep/functions/lt.js')
+  })
+
+  test('dep/folder should resolve to dep/folder/index.js', async (context) => {
+    const node_modules = {
+      'node_modules/my-dep/package.json': JSON.stringify({
+        name: 'my-dep',
+        version: '1.0.0',
+        main: 'index.js',
+      }),
+      'node_modules/my-dep/index.js': `export const main = 1`,
+      'node_modules/my-dep/folder/index.js': `export const folder = 42`,
+    }
+
+    const { fileMap } = await testBuild({
+      context,
+      files: {
+        ...node_modules,
+        'index.ts': `export { folder } from 'my-dep/folder'`,
+        'package.json': JSON.stringify({
+          name: 'test-pkg',
+          version: '1.0.0',
+          dependencies: { 'my-dep': '^1.0.0' },
+        }),
+      },
+    })
+
+    expect(fileMap['index.mjs']).toContain('my-dep/folder/index.js')
+  })
+})
+
 test('.node file bundle', async (context) => {
   const files = {
     'index.ts': `