Fix nested entry point resolution

Author: aryaemami59

src/api-extractor.ts

@@ -1,6 +1,11 @@
 import path from 'node:path'
 import { glob } from 'tinyglobby'
 import { handleError } from './errors'
+import {
+  type ExportDeclaration,
+  formatAggregationExports,
+  formatDistributionExports,
+} from './exports'
 import { loadPkg } from './load'
 import { createLogger } from './log'
 import {
@@ -9,7 +14,6 @@ import {
   getApiExtractor,
   removeFiles,
   toAbsolutePath,
-  toObjectEntry,
   writeFileSync,
 } from './utils'
 import type {
@@ -23,7 +27,7 @@ import type {
   IConfigFile,
   IExtractorConfigPrepareOptions,
 } from '@microsoft/api-extractor'
-import { formatAggregationExports, formatDistributionExports, type ExportDeclaration } from "./exports"
+import type { InputOption } from 'rollup'
 
 const logger = createLogger()
 
@@ -124,16 +128,11 @@ async function rollupDtsFiles(
     formatAggregationExports(exports, declarationDir),
   )
 
-  rollupDtsFile(
-    dtsInputFilePath,
-    dtsOutputFilePath,
-    tsconfig,
-  )
+  rollupDtsFile(dtsInputFilePath, dtsOutputFilePath, tsconfig)
 
   for (let [out, sourceFileName] of Object.entries(
     options.experimentalDts.entry,
   )) {
-    out = path.basename(out)
     /**
      * **Source file name** (`src/index.ts`)
      *
@@ -208,6 +207,84 @@ export async function runDtsRollup(
   }
 }
 
+/**
+ * Converts an array of {@linkcode NormalizedOptions.entry | entry paths}
+ * into an object where the keys represent the output
+ * file names (without extensions) and the values
+ * represent the corresponding input file paths.
+ *
+ * @param arrayOfEntries - An array of file path entries as strings.
+ * @returns An object where the keys are the output file name and the values are the input file name.
+ *
+ * @example
+ * <caption>### Convert an array of entry points to an entry point object</caption>
+ *
+ * ```ts
+ * import { defineConfig } from 'tsup'
+ *
+ * export default defineConfig({
+ *   entry: ['src/index.ts', 'src/types.ts'], // Becomes `{ index: 'src/index.ts', types: 'src/types.ts' }`
+ *   format: ['esm', 'cjs'],
+ * })
+ * ```
+ *
+ * @internal
+ */
+const convertArrayEntriesToObjectEntries = (arrayOfEntries: string[]) => {
+  const objectEntries = Object.fromEntries(
+    arrayOfEntries.map(
+      (entry) =>
+        [
+          path.posix.join(
+            ...entry
+              .split(path.posix.sep)
+              .slice(1, -1)
+              .concat(path.parse(entry).name),
+          ),
+          entry,
+        ] as const,
+    ),
+  )
+
+  return objectEntries
+}
+
+/**
+ * Resolves and standardizes entry paths into an object format.
+ * If the provided entry is a string or an array of strings, it resolves
+ * any potential glob patterns using
+ * {@linkcode glob | tiny-glob's glob function}
+ * and converts the result into an entry object.
+ * If the input is already an object, it is returned as-is.
+ *
+ * @param entryPaths - The entry paths to resolve. Can be a string, an array of strings, or an object.
+ * @returns A {@linkcode Promise} that resolves to the standardized entry paths in object format.
+ *
+ * @example
+ *
+ * ```ts
+ * import { defineConfig } from 'tsup'
+ *
+ * export default defineConfig({
+ *   entry: { index: 'src/index.ts' },
+ *   format: ['esm', 'cjs'],
+ *   experimentalDts: { entry: 'src/**\/*.ts' },
+ *   // experimentalDts: { entry: 'src/**\/*.ts' }
+ *   // becomes experimentalDts: { entry: { index: 'src/index.ts', types: 'src/types.ts } }
+ * })
+ * ```
+ *
+ * @internal
+ */
+const resolveEntryPaths = async (entryPaths: InputOption) => {
+  const resolvedEntryPaths =
+    typeof entryPaths === 'string' || Array.isArray(entryPaths)
+      ? convertArrayEntriesToObjectEntries(await glob(entryPaths))
+      : entryPaths
+
+  return resolvedEntryPaths
+}
+
 /**
  * Normalizes the
  * {@linkcode NormalizedExperimentalDtsConfig | experimental DTS options}
@@ -224,44 +301,21 @@ export const normalizeExperimentalDtsOptions = async (
   options: Partial<NormalizedOptions>,
   tsconfig: any,
 ) => {
-  if (options.entry == null) {
+  if (!options.entry || !options.experimentalDts) {
     return
   }
 
-  const experimentalDtsEntry = options.experimentalDts?.entry || options.entry
-
-  /**
-   * Resolves the entry paths for the experimental DTS configuration.
-   * If the entry is a string or array of strings,
-   * it uses {@linkcode glob | tinyglobby's glob function} to resolve
-   * the potential glob patterns. If it's an `object`, it directly uses
-   * the provided entry object.
-   *
-   * @example
-   *
-   * ```ts
-   * import { defineConfig } from 'tsup'
-   *
-   * export default defineConfig({
-   *   entry: { index: 'src/index.ts' },
-   *   format: ['esm', 'cjs'],
-   *   experimentalDts: { entry: 'src/**\/*.ts' },
-   *   // experimentalDts: { entry: 'src/**\/*.ts' }
-   *   // becomes experimentalDts: { entry: { index: 'src/index.ts', types: 'src/types.ts } }
-   * })
-   * ```
-   */
-  const resolvedEntryPaths =
-    typeof experimentalDtsEntry === 'string' ||
-    Array.isArray(experimentalDtsEntry)
-      ? await glob(experimentalDtsEntry)
-      : experimentalDtsEntry
+  const resolvedEntryPaths = await resolveEntryPaths(
+    options.experimentalDts.entry || options.entry,
+  )
 
   // Fallback to `options.entry` if we end up with an empty object.
   const experimentalDtsObjectEntry =
-    Object.keys(toObjectEntry(resolvedEntryPaths)).length === 0
-      ? toObjectEntry(options.entry)
-      : toObjectEntry(resolvedEntryPaths)
+    Object.keys(resolvedEntryPaths).length === 0
+      ? Array.isArray(options.entry)
+        ? convertArrayEntriesToObjectEntries(options.entry)
+        : options.entry
+      : resolvedEntryPaths
 
   const normalizedExperimentalDtsOptions: NormalizedExperimentalDtsConfig = {
     compilerOptions: {
@@ -298,21 +352,22 @@ export const normalizeInitialExperimentalDtsOptions = async (
   if (experimentalDts == null) {
     return
   }
+
   if (typeof experimentalDts === 'boolean')
     return experimentalDts ? { entry: {} } : undefined
+
   if (typeof experimentalDts === 'string') {
-    return { entry: toObjectEntry(await glob(experimentalDts)) }
+    return {
+      entry: convertArrayEntriesToObjectEntries(await glob(experimentalDts)),
+    }
   }
+
   return {
     ...experimentalDts,
+
     entry:
       experimentalDts?.entry == null
         ? {}
-        : toObjectEntry(
-            typeof experimentalDts?.entry === 'string' ||
-              Array.isArray(experimentalDts.entry)
-              ? await glob(experimentalDts.entry)
-              : experimentalDts.entry,
-          ),
+        : await resolveEntryPaths(experimentalDts.entry),
   }
 }

src/index.ts

@@ -140,12 +140,10 @@ const normalizeOptions = async (
       }
     }
 
-    if (options.experimentalDts) {
-      options.experimentalDts = await normalizeExperimentalDtsOptions(
-        options,
-        tsconfig,
-      )
-    }
+    options.experimentalDts = await normalizeExperimentalDtsOptions(
+      options,
+      tsconfig,
+    )
 
     if (!options.target) {
       options.target = tsconfig.data?.compilerOptions?.target?.toLowerCase()