feat(entry): support glob negation patterns in object entry (#662)

Co-authored-by: Kevin Deng <sxzz@sxzz.moe>

Author: Doctor-wu

src/config/options.ts

@@ -120,7 +120,7 @@ export async function resolveUserConfig(
   outDir = path.resolve(cwd, outDir)
   clean = resolveClean(clean, outDir, cwd)
 
-  entry = await resolveEntry(logger, entry, cwd, color, nameLabel)
+  const resolvedEntry = await resolveEntry(logger, entry, cwd, color, nameLabel)
   if (dts == null) {
     dts = !!(pkg?.types || pkg?.typings || hasExportsTypes(pkg))
   }
@@ -227,7 +227,7 @@ export async function resolveUserConfig(
     cwd,
     debug,
     dts,
-    entry,
+    entry: resolvedEntry,
     env,
     exports,
     external,

src/config/types.ts

@@ -29,7 +29,6 @@ import type { Hookable } from 'hookable'
 import type { Options as PublintOptions } from 'publint'
 import type {
   ExternalOption,
-  InputOption,
   InputOptions,
   InternalModuleFormat,
   MinifyOptions,
@@ -44,6 +43,29 @@ import type { Options as UnusedOptions } from 'unplugin-unused'
 export type Sourcemap = boolean | 'inline' | 'hidden'
 export type Format = ModuleFormat
 export type NormalizedFormat = InternalModuleFormat
+
+/**
+ * Extended input option that supports glob negation patterns.
+ *
+ * When using object form, values can be:
+ * - A single glob pattern string
+ * - An array of glob patterns, including negation patterns (prefixed with `!`)
+ *
+ * @example
+ * ```ts
+ * entry: {
+ *   // Single pattern
+ *   "utils/*": "./src/utils/*.ts",
+ *   // Array with negation pattern to exclude files
+ *   "hooks/*": ["./src/hooks/*.ts", "!./src/hooks/index.ts"],
+ * }
+ * ```
+ */
+export type TsdownInputOption =
+  | string
+  | string[]
+  | Record<string, string | string[]>
+
 export type {
   AttwOptions,
   BuildContext,
@@ -113,8 +135,16 @@ export interface UserConfig {
   // #region Input Options
   /**
    * Defaults to `'src/index.ts'` if it exists.
+   *
+   * Supports glob patterns with negation to exclude files:
+   * @example
+   * ```ts
+   * entry: {
+   *   "hooks/*": ["./src/hooks/*.ts", "!./src/hooks/index.ts"],
+   * }
+   * ```
    */
-  entry?: InputOption
+  entry?: TsdownInputOption
 
   external?: ExternalOption
   noExternal?: Arrayable<string | RegExp> | NoExternalFn
@@ -553,6 +583,8 @@ export type ResolvedConfig = Overwrite<
     | 'footer'
   >,
   {
+    /** Resolved entry map (after glob expansion) */
+    entry: Record<string, string>
     nameLabel: string | undefined
     format: NormalizedFormat
     target?: string[]

src/features/entry.test.ts

@@ -113,4 +113,76 @@ describe('toObjectEntry', () => {
       'src/bar': path.join(testDir, 'src/bar.ts'),
     })
   })
+
+  // #660
+  test('object entry with glob negation pattern', async (context) => {
+    const { testDir } = await writeFixtures(context, {
+      'src/hooks/index.ts': '',
+      'src/hooks/useAuth.ts': '',
+      'src/hooks/useUser.ts': '',
+    })
+    const result = await toObjectEntry(
+      {
+        'hooks/*': ['src/hooks/*.ts', '!src/hooks/index.ts'],
+      },
+      testDir,
+    )
+    expect(result).toEqual({
+      'hooks/useAuth': path.join(testDir, 'src/hooks/useAuth.ts'),
+      'hooks/useUser': path.join(testDir, 'src/hooks/useUser.ts'),
+    })
+    expect(Object.keys(result)).not.toContain('hooks/index')
+  })
+
+  test('object entry with multiple negation patterns', async (context) => {
+    const { testDir } = await writeFixtures(context, {
+      'src/utils/index.ts': '',
+      'src/utils/internal.ts': '',
+      'src/utils/helper.ts': '',
+      'src/utils/format.ts': '',
+    })
+    const result = await toObjectEntry(
+      {
+        'utils/*': [
+          'src/utils/*.ts',
+          '!src/utils/index.ts',
+          '!src/utils/internal.ts',
+        ],
+      },
+      testDir,
+    )
+    expect(result).toEqual({
+      'utils/helper': path.join(testDir, 'src/utils/helper.ts'),
+      'utils/format': path.join(testDir, 'src/utils/format.ts'),
+    })
+  })
+
+  test('object entry with multiple positive patterns should throw', async (context) => {
+    const { testDir } = await writeFixtures(context, {
+      'src/hooks/useAuth.ts': '',
+      'src/utils/helper.ts': '',
+    })
+    await expect(
+      toObjectEntry(
+        {
+          'lib/*': ['src/hooks/*.ts', 'src/utils/*.ts'],
+        },
+        testDir,
+      ),
+    ).rejects.toThrow(/multiple positive patterns/)
+  })
+
+  test('object entry with no positive pattern should throw', async (context) => {
+    const { testDir } = await writeFixtures(context, {
+      'src/hooks/useAuth.ts': '',
+    })
+    await expect(
+      toObjectEntry(
+        {
+          'hooks/*': ['!src/hooks/index.ts'],
+        },
+        testDir,
+      ),
+    ).rejects.toThrow(/no positive pattern/)
+  })
 })

src/features/entry.ts

@@ -2,7 +2,7 @@ import path from 'node:path'
 import picomatch from 'picomatch'
 import { glob, isDynamicPattern } from 'tinyglobby'
 import { fsExists, lowestCommonAncestor, stripExtname } from '../utils/fs.ts'
-import { slash } from '../utils/general.ts'
+import { slash, toArray } from '../utils/general.ts'
 import type { UserConfig } from '../config/index.ts'
 import type { Logger } from '../utils/logger.ts'
 import type { Ansis } from 'ansis'
@@ -39,7 +39,7 @@ export async function resolveEntry(
 }
 
 export async function toObjectEntry(
-  entry: string | string[] | Record<string, string>,
+  entry: string | string[] | Record<string, string | string[]>,
   cwd: string,
 ): Promise<Record<string, string>> {
   if (typeof entry === 'string') {
@@ -51,10 +51,34 @@ export async function toObjectEntry(
       (
         await Promise.all(
           Object.entries(entry).map(async ([key, value]) => {
-            if (!key.includes('*')) return [[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.`,
+                )
+              }
 
-            const valueGlob = picomatch.scan(value)
-            const files = await glob(value, {
+              return [[key, value]]
+            }
+
+            const patterns = toArray(value)
+
+            const positivePatterns = patterns.filter((p) => !p.startsWith('!'))
+            if (positivePatterns.length === 0) {
+              throw new TypeError(
+                `Object entry "${key}" has no positive pattern. At least one positive pattern is required.`,
+              )
+            }
+
+            if (positivePatterns.length > 1) {
+              throw new TypeError(
+                `Object entry "${key}" has multiple positive patterns: ${positivePatterns.join(', ')}. ` +
+                  `Only one positive pattern is allowed. Use negation patterns (prefixed with "!") to exclude files.`,
+              )
+            }
+
+            const valueGlob = picomatch.scan(positivePatterns[0])
+            const files = await glob(patterns, {
               cwd,
               expandDirectories: false,
             })