fix(exports): detect types fields nested in conditional exports

Recursively walk the exports tree so nested type conditions
(e.g. exports['.'].import.types) are picked up as a signal for
auto-enabling dts generation. Previously only top-level and
exports['.'].types were checked.

Closes #885

Author: sxzz

src/config/options.ts

@@ -171,7 +171,9 @@ export async function resolveUserConfig(
   exe = resolveFeatureOption(exe, {})
 
   if (dts == null) {
-    dts = exe ? false : !!(pkg?.types || pkg?.typings || hasExportsTypes(pkg))
+    dts = exe
+      ? false
+      : !!(pkg?.types || pkg?.typings || hasExportsTypes(pkg?.exports))
   }
   dts = resolveFeatureOption(dts, {})
 

src/features/pkg/exports.test.ts

@@ -1,8 +1,11 @@
 import path from 'node:path'
 import process from 'node:process'
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { globalLogger } from '../../utils/logger.ts'
-import { generateExports as _generateExports } from './exports.ts'
+import {
+  generateExports as _generateExports,
+  hasExportsTypes,
+} from './exports.ts'
 import type { ResolvedConfig } from '../../config/types.ts'
 import type { ChunksByFormat, RolldownChunk } from '../../utils/chunks.ts'
 
@@ -1149,6 +1152,62 @@ describe('generateExports', () => {
   })
 })
 
+describe('hasExportsTypes', () => {
+  test('nullish or string', () => {
+    expect(hasExportsTypes(undefined)).toBe(false)
+    expect(hasExportsTypes(null)).toBe(false)
+    expect(hasExportsTypes('./index.js')).toBe(false)
+  })
+
+  test('top-level types condition', () => {
+    expect(
+      hasExportsTypes({ types: './index.d.ts', default: './index.js' }),
+    ).toBe(true)
+  })
+
+  test('types under "."', () => {
+    expect(
+      hasExportsTypes({
+        '.': { types: './index.d.ts', default: './index.js' },
+      }),
+    ).toBe(true)
+  })
+
+  test('types nested under "import" / "require" (issue #885)', () => {
+    expect(
+      hasExportsTypes({
+        '.': {
+          import: { default: './esm/index.js', types: './esm/index.d.ts' },
+          require: { default: './cjs/index.cjs', types: './cjs/index.d.cts' },
+        },
+      }),
+    ).toBe(true)
+  })
+
+  test('types under arbitrary subpath', () => {
+    expect(
+      hasExportsTypes({
+        './utils': { types: './utils.d.ts', default: './utils.js' },
+      }),
+    ).toBe(true)
+  })
+
+  test('types in array fallback', () => {
+    expect(
+      hasExportsTypes({ '.': [{ types: './index.d.ts' }, './index.js'] }),
+    ).toBe(true)
+  })
+
+  test('no types anywhere', () => {
+    expect(
+      hasExportsTypes({
+        '.': { import: './esm/index.js', require: './cjs/index.cjs' },
+        './utils': './utils.js',
+      }),
+    ).toBe(false)
+  })
+})
+
 function genChunk(
   fileName: string,
   isEntry = true,

src/features/pkg/exports.ts

@@ -487,34 +487,11 @@ function exportCss(
   }
 }
 
-export function hasExportsTypes(pkg?: PackageJson): boolean {
-  const exports = pkg?.exports
-  if (!exports) return false
-
-  if (
-    typeof exports === 'object' &&
-    exports !== null &&
-    !Array.isArray(exports)
-  ) {
-    // Check if exports.types exists
-    if ('types' in exports) {
-      return true
-    }
-
-    // Check if exports['.'].types exists
-    if ('.' in exports) {
-      const mainExport = exports['.']
-      if (
-        typeof mainExport === 'object' &&
-        mainExport !== null &&
-        'types' in mainExport
-      ) {
-        return true
-      }
-    }
-  }
-
-  return false
+export function hasExportsTypes(value: unknown): boolean {
+  if (value == null || typeof value !== 'object') return false
+  if (Array.isArray(value)) return value.some(hasExportsTypes)
+  if ('types' in value) return true
+  return Object.values(value).some(hasExportsTypes)
 }
 
 const RE_SHEBANG = /^#!.*/