feat(entry): support mixed array and object entries

closes #708

Author: sxzz

src/config/types.ts

@@ -63,10 +63,9 @@ export type NormalizedFormat = InternalModuleFormat
  * }
  * ```
  */
-export type TsdownInputOption =
-  | string
-  | string[]
-  | Record<string, string | string[]>
+export type TsdownInputOption = Arrayable<
+  string | Record<string, Arrayable<string>>
+>
 
 export type {
   AttwOptions,

src/features/entry.test.ts

@@ -190,4 +190,28 @@ describe('toObjectEntry', () => {
       ),
     ).rejects.toThrow('Cannot find files')
   })
+
+  test('mixed object and array entry', async (context) => {
+    const { testDir } = await writeFixtures(context, {
+      'index.ts': '',
+      'src/foo.ts': '',
+      'src/bar.ts': '',
+    })
+    const result = await toObjectEntry(
+      [
+        'src/*',
+        '!src/foo.ts',
+
+        { main: 'index.ts' },
+        { 'lib/*': ['src/*.ts', '!src/bar.ts'] },
+        { bar: 'override by object' },
+      ],
+      testDir,
+    )
+    expect(result).toEqual({
+      main: 'index.ts',
+      bar: 'override by object',
+      'lib/foo': path.join(testDir, 'src/foo.ts'),
+    })
+  })
 })

src/features/entry.ts

@@ -3,8 +3,9 @@ import picomatch from 'picomatch'
 import { glob, isDynamicPattern } from 'tinyglobby'
 import { fsExists, lowestCommonAncestor, stripExtname } from '../utils/fs.ts'
 import { slash, toArray } from '../utils/general.ts'
-import type { UserConfig } from '../config/index.ts'
+import type { TsdownInputOption, UserConfig } from '../config/types.ts'
 import type { Logger } from '../utils/logger.ts'
+import type { Arrayable } from '../utils/types.ts'
 import type { Ansis } from 'ansis'
 
 export async function resolveEntry(
@@ -38,94 +39,125 @@ export async function resolveEntry(
   return entryMap
 }
 
-export async function toObjectEntry(
-  entry: string | string[] | Record<string, string | string[]>,
+export function toObjectEntry(
+  entry: TsdownInputOption,
   cwd: string,
 ): Promise<Record<string, string>> {
   if (typeof entry === 'string') {
     entry = [entry]
   }
-  if (!Array.isArray(entry)) {
-    // resolve object entry with globs
-    return Object.fromEntries(
-      (
-        await Promise.all(
-          Object.entries(entry).map(async ([key, value]) => {
-            if (!key.includes('*')) {
-              if (Array.isArray(value)) {
-                throw new TypeError(
-                  `Object entry "${key}" cannot have an array value when the key is not a glob pattern.`,
-                )
-              }
 
-              return [[key, value]]
-            }
+  if (!Array.isArray(entry)) {
+    return resolveObjectEntry(entry, cwd)
+  }
+  return resolveArrayEntry(entry, cwd)
+}
 
-            const patterns = toArray(value)
-            const files = await glob(patterns, {
-              cwd,
-              expandDirectories: false,
-            })
-            if (!files.length) {
-              throw new Error(
-                `Cannot find files for entry key "${key}" with patterns: ${JSON.stringify(
-                  patterns,
-                )}`,
+async function resolveObjectEntry(
+  entries: Record<string, string | string[]>,
+  cwd: string,
+) {
+  return Object.fromEntries(
+    (
+      await Promise.all(
+        Object.entries(entries).map(async ([key, value]) => {
+          if (!key.includes('*')) {
+            if (Array.isArray(value)) {
+              throw new TypeError(
+                `Object entry "${key}" cannot have an array value when the key is not a glob pattern.`,
               )
             }
 
-            let valueGlobBase: string | undefined
-            for (const pattern of patterns) {
-              if (pattern.startsWith('!')) continue
-              const base = picomatch.scan(pattern).base
-              if (valueGlobBase === undefined) {
-                valueGlobBase = base
-              } else if (valueGlobBase !== base) {
-                throw new Error(
-                  `When using object entry with glob pattern key "${key}", all value glob patterns must have the same base directory.`,
-                )
-              }
-            }
+            return [[key, value]]
+          }
+
+          const patterns = toArray(value)
+          const files = await glob(patterns, {
+            cwd,
+            expandDirectories: false,
+          })
+          if (!files.length) {
+            throw new Error(
+              `Cannot find files for entry key "${key}" with patterns: ${JSON.stringify(
+                patterns,
+              )}`,
+            )
+          }
+
+          let valueGlobBase: string | undefined
+          for (const pattern of patterns) {
+            if (pattern.startsWith('!')) continue
+            const base = picomatch.scan(pattern).base
             if (valueGlobBase === undefined) {
+              valueGlobBase = base
+            } else if (valueGlobBase !== base) {
               throw new Error(
-                `Cannot determine base directory for value glob patterns of key "${key}".`,
+                `When using object entry with glob pattern key "${key}", all value glob patterns must have the same base directory.`,
               )
             }
+          }
+          if (valueGlobBase === undefined) {
+            throw new Error(
+              `Cannot determine base directory for value glob patterns of key "${key}".`,
+            )
+          }
 
-            return files.map((file) => [
-              slash(
-                key.replaceAll(
-                  '*',
-                  stripExtname(path.relative(valueGlobBase, file)),
-                ),
+          return files.map((file) => [
+            slash(
+              key.replaceAll(
+                '*',
+                stripExtname(path.relative(valueGlobBase, file)),
               ),
-              path.resolve(cwd, file),
-            ])
-          }),
-        )
-      ).flat(),
-    )
+            ),
+            path.resolve(cwd, file),
+          ])
+        }),
+      )
+    ).flat(),
+  )
+}
+
+async function resolveArrayEntry(
+  entries: (string | Record<string, Arrayable<string>>)[],
+  cwd: string,
+) {
+  const stringEntries: string[] = []
+  const objectEntries: Record<string, Arrayable<string>>[] = []
+  for (const e of entries) {
+    if (typeof e === 'string') {
+      stringEntries.push(e)
+    } else {
+      objectEntries.push(e)
+    }
   }
 
-  const isGlob = entry.some((e) => isDynamicPattern(e))
-  let resolvedEntry: string[]
+  const isGlob = stringEntries.some((e) => isDynamicPattern(e))
+  let resolvedEntries: string[]
   if (isGlob) {
-    resolvedEntry = (
-      await glob(entry, {
+    resolvedEntries = (
+      await glob(stringEntries, {
         cwd,
         expandDirectories: false,
         absolute: true,
       })
     ).map((file) => path.resolve(file))
   } else {
-    resolvedEntry = entry
+    resolvedEntries = stringEntries
   }
 
-  const base = lowestCommonAncestor(...resolvedEntry)
-  return Object.fromEntries(
-    resolvedEntry.map((file) => {
+  const base = lowestCommonAncestor(...resolvedEntries)
+  const arrayEntryMap = Object.fromEntries(
+    resolvedEntries.map((file) => {
       const relative = path.relative(base, file)
       return [slash(stripExtname(relative)), file]
     }),
   )
+
+  return Object.assign(
+    {},
+    arrayEntryMap,
+    ...(await Promise.all(
+      objectEntries.map((entry) => resolveObjectEntry(entry, cwd)),
+    )),
+  )
 }