fix: derive declaration paths from entry points instead of scanning all files

Author: danielroe

shared/utils/package-analysis.ts

@@ -219,10 +219,92 @@ export function getCreateShortName(createPackageName: string): string {
   return createPackageName
 }
 
-function hasImplicitTypesInFiles(files: Set<string>): boolean {
-  return Array.from(files).some(
-    p => p.endsWith('.d.ts') || p.endsWith('.d.mts') || p.endsWith('.d.cts'),
-  )
+/**
+ * Map of JS extensions to their corresponding declaration file extensions.
+ */
+const DECLARATION_EXTENSIONS: Record<string, string[]> = {
+  '.mjs': ['.d.mts', '.d.ts'],
+  '.cjs': ['.d.cts', '.d.ts'],
+  '.js': ['.d.ts', '.d.mts', '.d.cts'],
+}
+
+/**
+ * Collect concrete file paths from the exports field, skipping the "types"
+ * condition (which is already checked by analyzeExports).
+ */
+function collectExportPaths(exports: PackageExports, depth = 0): string[] {
+  if (depth > 10) return []
+  if (exports === null || exports === undefined) return []
+
+  if (typeof exports === 'string') {
+    return [exports]
+  }
+
+  if (Array.isArray(exports)) {
+    return exports.flatMap(item => collectExportPaths(item, depth + 1))
+  }
+
+  if (typeof exports === 'object') {
+    const paths: string[] = []
+    for (const [key, value] of Object.entries(exports)) {
+      // Skip "types" condition — already detected by analyzeExports
+      if (key === 'types') continue
+      paths.push(...collectExportPaths(value, depth + 1))
+    }
+    return paths
+  }
+
+  return []
+}
+
+/**
+ * Normalize a path by stripping a leading "./" prefix.
+ */
+function stripRelativePrefix(p: string): string {
+  return p.startsWith('./') ? p.slice(2) : p
+}
+
+/**
+ * Derive expected declaration file paths from a JS entry point path.
+ * e.g. "./dist/index.mjs" -> ["dist/index.d.mts", "dist/index.d.ts"]
+ */
+function getDeclCandidates(entryPath: string): string[] {
+  const normalized = stripRelativePrefix(entryPath)
+  for (const [ext, declExts] of Object.entries(DECLARATION_EXTENSIONS)) {
+    if (normalized.endsWith(ext)) {
+      const base = normalized.slice(0, -ext.length)
+      return declExts.map(de => base + de)
+    }
+  }
+  return []
+}
+
+/**
+ * Check if declaration files exist for any of the package's entry points.
+ * Derives expected declaration paths from exports/main/module entry points
+ * (e.g. .d.mts for .mjs) and checks if they exist in the published files.
+ */
+function hasImplicitTypesForEntryPoints(pkg: ExtendedPackageJson, files: Set<string>): boolean {
+  const entryPaths: string[] = []
+
+  if (pkg.exports) {
+    entryPaths.push(...collectExportPaths(pkg.exports))
+  }
+  if (pkg.main) {
+    entryPaths.push(pkg.main)
+  }
+  if (pkg.module) {
+    entryPaths.push(pkg.module)
+  }
+
+  for (const entryPath of entryPaths) {
+    const candidates = getDeclCandidates(entryPath)
+    if (candidates.some(c => files.has(c))) {
+      return true
+    }
+  }
+
+  return false
 }
 
 /**
@@ -246,9 +328,9 @@ export function detectTypesStatus(
     }
   }
 
-  // Check for implicit types (e.g. .d.mts next to .mjs, TypeScript automatic lookup)
-  // Collect paths from exports/main/module and check if declaration files exist
-  if (files && hasImplicitTypesInFiles(files)) {
+  // Check for implicit types by deriving expected declaration file paths from
+  // entry points (e.g. .d.mts for .mjs) and checking if they exist in the package
+  if (files && hasImplicitTypesForEntryPoints(pkg, files)) {
     return { kind: 'included' }
   }
 

test/unit/shared/utils/package-analysis.spec.ts

@@ -167,7 +167,7 @@ describe('detectTypesStatus', () => {
     expect(detectTypesStatus({})).toEqual({ kind: 'none' })
   })
 
-  it('detects included types when declaration file exists in files', () => {
+  it('detects included types when matching declaration file exists for entry point', () => {
     expect(
       detectTypesStatus(
         { type: 'module', exports: { '.': './dist/index.mjs' } },
@@ -176,10 +176,20 @@ describe('detectTypesStatus', () => {
       ),
     ).toEqual({ kind: 'included' })
   })
+
+  it('does not detect types from unrelated .d.ts files in the package', () => {
+    expect(
+      detectTypesStatus(
+        { type: 'module', exports: { '.': './dist/index.mjs' } },
+        undefined,
+        new Set(['dist/index.mjs', 'env.d.ts', 'shims-vue.d.ts']),
+      ),
+    ).toEqual({ kind: 'none' })
+  })
 })
 
-describe('detectTypesStatus implicit types (path derivation)', () => {
-  it('derives .d.mts from .mjs in exports', () => {
+describe('detectTypesStatus implicit types from entry points', () => {
+  it('finds .d.mts matching .mjs export entry point', () => {
     expect(
       detectTypesStatus(
         { type: 'module', exports: { '.': './dist/index.mjs' } },
@@ -189,7 +199,7 @@ describe('detectTypesStatus implicit types (path derivation)', () => {
     ).toEqual({ kind: 'included' })
   })
 
-  it('derives .d.cts from .cjs in exports', () => {
+  it('finds .d.cts matching .cjs export entry point', () => {
     expect(
       detectTypesStatus(
         { exports: { '.': { require: './dist/index.cjs' } } },
@@ -199,7 +209,17 @@ describe('detectTypesStatus implicit types (path derivation)', () => {
     ).toEqual({ kind: 'included' })
   })
 
-  it('derives .d.mts from main when type is module', () => {
+  it('finds .d.ts matching .js export entry point', () => {
+    expect(
+      detectTypesStatus(
+        { exports: { '.': './dist/index.js' } },
+        undefined,
+        new Set(['dist/index.d.ts']),
+      ),
+    ).toEqual({ kind: 'included' })
+  })
+
+  it('finds .d.mts matching .mjs main entry point', () => {
     expect(
       detectTypesStatus(
         { type: 'module', main: 'dist/index.mjs' },
@@ -208,22 +228,45 @@ describe('detectTypesStatus implicit types (path derivation)', () => {
       ),
     ).toEqual({ kind: 'included' })
   })
+
+  it('finds .d.ts matching .js module entry point', () => {
+    expect(
+      detectTypesStatus({ module: './dist/index.js' }, undefined, new Set(['dist/index.d.ts'])),
+    ).toEqual({ kind: 'included' })
+  })
+
+  it('returns none when no declaration file matches any entry point', () => {
+    expect(
+      detectTypesStatus(
+        { type: 'module', exports: { '.': './dist/index.mjs' } },
+        undefined,
+        new Set(['dist/other.d.mts', 'types/env.d.ts']),
+      ),
+    ).toEqual({ kind: 'none' })
+  })
 })
 
 describe('analyzePackage with files (implicit types)', () => {
-  it('detects included types when declaration file exists in files', () => {
+  it('detects included types when matching declaration file exists for entry point', () => {
     const pkg = { type: 'module' as const, exports: { '.': './dist/index.mjs' } }
     const files = new Set(['dist/index.mjs', 'dist/index.d.mts'])
     const result = analyzePackage(pkg, { files })
     expect(result.types).toEqual({ kind: 'included' })
   })
 
-  it('returns none when declaration file does not exist in files', () => {
+  it('returns none when no declaration file matches entry point', () => {
     const pkg = { type: 'module' as const, exports: { '.': './dist/index.mjs' } }
     const files = new Set(['dist/index.mjs'])
     const result = analyzePackage(pkg, { files })
     expect(result.types).toEqual({ kind: 'none' })
   })
+
+  it('returns none when only unrelated .d.ts files exist', () => {
+    const pkg = { type: 'module' as const, exports: { '.': './dist/index.mjs' } }
+    const files = new Set(['dist/index.mjs', 'env.d.ts'])
+    const result = analyzePackage(pkg, { files })
+    expect(result.types).toEqual({ kind: 'none' })
+  })
 })
 
 describe('getTypesPackageName', () => {