fix(cli): camel-case nested flag keys

cac camel-cases only the first segment of a dotted flag, so
`--deps.never-bundle` was parsed as `deps['never-bundle']` and silently
ignored, along with every other nested kebab-case flag such as
`--deps.always-bundle`, `--dts.emit-dts-only` or `--exports.dev-exports`.

Normalize all nested keys right after parsing, keeping options whose keys
are user-defined (`env`, `define`, `alias`, `entry`, `loader`,
`inputOptions.moduleTypes`, `outputOptions.globals`) verbatim.

close #1058

Author: sxzz

docs/reference/cli.md

@@ -11,7 +11,9 @@ The mapping between CLI flags and configuration options follows these rules:
 - `--foo.bar` sets `foo: { bar: true }`
 - `--format esm --format cjs` sets `format: ['esm', 'cjs']`
 
-CLI flags support both camelCase and kebab-case. For example, `--outDir` and `--out-dir` are equivalent.
+CLI flags support both camelCase and kebab-case. For example, `--outDir` and `--out-dir` are equivalent. Nested keys follow the same rule, so `--deps.never-bundle` and `--deps.neverBundle` are equivalent as well.
+
+Options whose keys are defined by you — `--env.*`, `--define.*`, `--alias.*`, `--entry.*` and `--loader.*` — are the exception: their keys are used exactly as written.
 
 This flexible pattern allows you to easily control and override configuration options directly from the command line.
 

pnpm-workspace.yaml

@@ -100,4 +100,3 @@ minimumReleaseAge: 0
 trustLockfile: true
 trustPolicy: no-downgrade
 trustPolicyIgnoreAfter: 10080 # 7 days
-virtualStoreType: global

src/cli.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { parseCLI } from './cli.ts'
+
+function parse(...args: string[]): Record<string, any> {
+  return parseCLI(['node', 'tsdown', ...args]).options
+}
+
+describe('parseCLI', () => {
+  it('camel-cases nested option keys', () => {
+    expect(parse('--deps.never-bundle', 'leftpad').deps).toEqual({
+      neverBundle: 'leftpad',
+    })
+    expect(parse('--deps.neverBundle', 'leftpad').deps).toEqual({
+      neverBundle: 'leftpad',
+    })
+    expect(parse('--deps.dts.never-bundle', 'leftpad').deps).toEqual({
+      dts: { neverBundle: 'leftpad' },
+    })
+  })
+
+  it('keeps user-defined keys verbatim', () => {
+    const options = parse(
+      '--env.my-var',
+      'a',
+      '--define.my-flag',
+      'b',
+      '--alias.my-lib',
+      './src/my-lib.ts',
+    )
+    expect(options.env).toEqual({ 'my-var': 'a' })
+    expect(options.define).toEqual({ 'my-flag': 'b' })
+    expect(options.alias).toEqual({ 'my-lib': './src/my-lib.ts' })
+  })
+
+  it('leaves top-level flags and entries alone', () => {
+    const { args, options } = parseCLI([
+      'node',
+      'tsdown',
+      'src/index.ts',
+      '--out-dir',
+      'lib',
+    ])
+    expect(args).toEqual(['src/index.ts'])
+    expect(options.outDir).toBe('lib')
+  })
+})

src/cli.ts

@@ -1,6 +1,6 @@
 /* eslint-disable unicorn/no-top-level-side-effects */
 import process from 'node:process'
-import { cac } from 'cac'
+import { cac, type CAC } from 'cac'
 import { VERSION as rolldownVersion } from 'rolldown'
 import { x } from 'tinyexec'
 import pkg from '../package.json' with { type: 'json' }
@@ -130,10 +130,61 @@ cli
     process.exitCode = exitCode
   })
 
+/**
+ * Options whose nested keys are user-defined values (environment variable
+ * names, module ids, entry names, ...) instead of option names.
+ */
+const VERBATIM_KEYS: ReadonlySet<string> = new Set([
+  'alias',
+  'define',
+  'entry',
+  'env',
+  'loader',
+  'inputOptions.moduleTypes',
+  'outputOptions.globals',
+])
+
+/**
+ * cac camel-cases only the first segment of a dotted flag, so
+ * `--deps.never-bundle` is parsed as `deps['never-bundle']` while the config
+ * expects `deps.neverBundle`. Camel-case the remaining segments here, leaving
+ * the keys of {@linkcode VERBATIM_KEYS} untouched.
+ */
+function camelizeFlags(flags: Record<string, any>, path?: string): void {
+  for (const key of Object.keys(flags)) {
+    const camelKey = key.replaceAll(
+      /([a-z])-([a-z])/g,
+      (_, prev, next) => prev + next.toUpperCase(),
+    )
+    const value = flags[key]
+    const childPath = path ? `${path}.${camelKey}` : camelKey
+
+    if (
+      value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      !VERBATIM_KEYS.has(childPath)
+    ) {
+      camelizeFlags(value, childPath)
+    }
+
+    if (camelKey !== key) {
+      if (!(camelKey in flags)) flags[camelKey] = value
+      delete flags[key]
+    }
+  }
+}
+
+export function parseCLI(argv: string[]): ReturnType<CAC['parse']> {
+  const parsed = cli.parse(argv, { run: false })
+  camelizeFlags(parsed.options)
+  return parsed
+}
+
 export async function runCLI(): Promise<void> {
-  cli.parse(process.argv, { run: false })
+  const { options } = parseCLI(process.argv)
 
-  enableDebug(cli.options.debug)
+  enableDebug(options.debug)
 
   try {
     await cli.runMatchedCommand()