feat: emit idiomatic exports for module.exports object literals.

Author: knightedcodemonkey

docs/cli.md

@@ -23,7 +23,7 @@ dub [options] <files...>
 
 Examples:
 
-- Transform CJS to ESM into an output directory:
+- Transform CJS to ESM into an output directory (mirrors input paths inside the dir):
 
   ```bash
   dub -t module src/**/*.cjs --out-dir dist
@@ -47,6 +47,12 @@ Examples:
   cat input.cjs | dub -t module --stdin-filename input.cjs > output.mjs
   ```
 
+- Single-file rename via stdout redirect (CLI has no "out file" flag; `--out-dir` always mirrors inputs):
+
+  ```bash
+  dub -t module src/some.cjs > src/some.mjs
+  ```
+
 ## Options
 
 Short and long forms are supported.
@@ -83,5 +89,5 @@ Short and long forms are supported.
 Notes:
 
 - When reading from stdin, output is sent to stdout; `--out-dir` or `--in-place` are not allowed in that mode.
-- Specify either `--out-dir` or `--in-place` for file inputs; stdout is used only when a single file is given and neither flag is set.
+- Specify either `--out-dir` or `--in-place` for file inputs; stdout is used only when a single file is given and neither flag is set. `--out-dir` always mirrors the input path under that directory (no single-file rename flag). Use stdout redirection if you need to rename one file.
 - Diagnostics are printed to stderr; use `--json` for machine-readable output.

docs/roadmap.md

@@ -4,12 +4,11 @@ Status: draft
 
 ## Idiomatic Exports
 
-Shipped: `idiomaticExports: 'safe'` is now the default for CJS → ESM, with fallback to the helper bag plus diagnostics when unsafe.
+Shipped: `idiomaticExports: 'safe'` is now the default for CJS → ESM, with fallback to the helper bag plus diagnostics when unsafe. Auto lifts simple `module.exports = { foo, bar }` object literals to idiomatic exports when safe.
 
 Next:
 
 - Explore a true `'aggressive'` mode (mixed exports/module.exports, limited reassignments, identifier-safe computed keys) with guarded semantics and explicit diagnostics.
-- In `'auto'`, allow idiomatic `module.exports = { foo, bar }` when the object literal is simple: single top-level assignment, no spreads/getters/computed/duplicate keys, only identifier keys, RHS values limited to safe literals/identifiers/function|class expressions, no `require()` inside RHS, and no `__proto__`/`prototype` keys. Add a shorthand-object fixture test and keep falling back to the helper for anything more complex.
 - Consider a constrained ESM → CJS “pretty” path where live-binding and TLA semantics permit it.
 
 ## CLI

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/module",
-  "version": "1.3.0-rc.0",
+  "version": "1.3.0-rc.1",
   "description": "Bidirectional transform for ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",

package.json

@@ -740,7 +740,7 @@ const format = async (src: string, ast: ParseResult, opts: FormatterOptions) =>
         if (entry.reassignments.length) return { ok: false, reason: 'reassignment' }
         if (entry.hasNonTopLevelWrite) return { ok: false, reason: 'non-top-level' }
         if (entry.writes.length !== 1) return { ok: false, reason: 'multiple-writes' }
-        if (!isValidExportName(entry.key))
+        if (entry.key !== 'default' && !isValidExportName(entry.key))
           return { ok: false, reason: 'non-identifier-key' }
       }
 
@@ -759,6 +759,52 @@ const format = async (src: string, ast: ParseResult, opts: FormatterOptions) =>
           .replace(/\b__filename\b/g, 'import.meta.filename')
       }
 
+      const tryObjectLiteralExport = (
+        rhs: Node,
+        baseIsModuleExports: boolean,
+        propName: string,
+      ) => {
+        if (!baseIsModuleExports || propName !== 'exports') return null
+        if (rhs.type !== 'ObjectExpression') return null
+
+        const exportsOut: string[] = []
+        const seenKeys = new Set<string>()
+
+        for (const prop of rhs.properties) {
+          if (prop.type !== 'Property') return null
+          if (prop.kind !== 'init') return null
+          if (prop.computed || prop.method) return null
+
+          if (prop.key.type !== 'Identifier') return null
+          const key = prop.key.name
+
+          if (key === '__proto__' || key === 'prototype') return null
+          if (!isValidExportName(key)) return null
+          if (seenKeys.has(key)) return null
+
+          const value =
+            prop.value.type === 'Identifier' && prop.shorthand ? prop.key : prop.value
+
+          if (!isAllowedRhs(value)) return null
+          if (expressionHasRequireCall(value, requireShadowed)) return null
+
+          const rhsSrc = rhsSourceFor(value)
+          if (value.type === 'Identifier' && value.name === key) {
+            exportsOut.push(`export { ${key} };`)
+          } else if (value.type === 'Identifier') {
+            exportsOut.push(`export { ${rhsSrc} as ${key} };`)
+          } else {
+            exportsOut.push(`export const ${key} = ${rhsSrc};`)
+          }
+
+          seenKeys.add(key)
+        }
+
+        exportsOut.push(`export default ${rhsSourceFor(rhs)};`)
+
+        return { exportsOut, seenKeys }
+      }
+
       for (const entry of entries) {
         const write = entry.writes[0]
         if (write.type !== 'AssignmentExpression') {
@@ -778,28 +824,45 @@ const format = async (src: string, ast: ParseResult, opts: FormatterOptions) =>
         const propName = left.property.name
         const baseIsExports = base.type === 'Identifier' && base.name === 'exports'
         const baseIsModuleExports =
-          base.type === 'MemberExpression' &&
-          base.object.type === 'Identifier' &&
-          base.object.name === 'module' &&
-          base.property.type === 'Identifier' &&
-          base.property.name === 'exports'
+          (base.type === 'Identifier' &&
+            base.name === 'module' &&
+            propName === 'exports') ||
+          (base.type === 'MemberExpression' &&
+            base.object.type === 'Identifier' &&
+            base.object.name === 'module' &&
+            base.property.type === 'Identifier' &&
+            base.property.name === 'exports')
 
         if (!baseIsExports && !baseIsModuleExports) {
           return { ok: false, reason: 'unsupported-base' }
         }
 
         const rhs = write.right
-        if (!isAllowedRhs(rhs)) return { ok: false, reason: 'unsupported-rhs' }
-        if (expressionHasRequireCall(rhs, requireShadowed)) {
-          return { ok: false, reason: 'rhs-require' }
+        const objectLiteralPlan = tryObjectLiteralExport(
+          rhs,
+          baseIsModuleExports,
+          propName,
+        )
+        if (!objectLiteralPlan) {
+          if (!isAllowedRhs(rhs)) return { ok: false, reason: 'unsupported-rhs' }
+          if (expressionHasRequireCall(rhs, requireShadowed)) {
+            return { ok: false, reason: 'rhs-require' }
+          }
         }
 
         const rhsSrc = rhsSourceFor(rhs)
         if (propName === 'exports' && baseIsModuleExports) {
-          // module.exports = ... handles default
-          if (seen.has('default')) return { ok: false, reason: 'duplicate-default' }
-          seen.add('default')
-          exportsOut.push(`export default ${rhsSrc};`)
+          if (objectLiteralPlan) {
+            for (const line of objectLiteralPlan.exportsOut) {
+              exportsOut.push(line)
+            }
+            objectLiteralPlan.seenKeys.forEach(k => seen.add(k))
+          } else {
+            // module.exports = ... handles default
+            if (seen.has('default')) return { ok: false, reason: 'duplicate-default' }
+            seen.add('default')
+            exportsOut.push(`export default ${rhsSrc};`)
+          }
         } else {
           if (seen.has(propName)) return { ok: false, reason: 'duplicate-key' }
           seen.add(propName)
@@ -1162,11 +1225,14 @@ const format = async (src: string, ast: ParseResult, opts: FormatterOptions) =>
         code.overwrite(rep.start, rep.end, idiomaticPlan!.exports[idx])
       })
     } else {
-      for (const rep of idiomaticPlan.replacements) {
-        code.overwrite(rep.start, rep.end, ';')
+      const [first, ...rest] = idiomaticPlan.replacements
+      if (first) {
+        code.overwrite(first.start, first.end, idiomaticPlan.exports.join('\n'))
       }
-      if (idiomaticPlan.exports.length) {
-        code.append(`\n${idiomaticPlan.exports.join('\n')}\n`)
+      for (const rep of rest) {
+        const original = code.slice(rep.start, rep.end)
+        const hasSemicolon = original.trimEnd().endsWith(';')
+        code.overwrite(rep.start, rep.end, hasSemicolon ? ';' : '')
       }
     }
   }

src/format.ts

@@ -0,0 +1,3 @@
+module.exports = {
+  ['x']: 1,
+}

test/fixtures/exportsObjectComputed.cjs

@@ -0,0 +1,9 @@
+const foo = 1
+const bar = () => 'bar'
+const Baz = class {
+  value() {
+    return 'baz'
+  }
+}
+
+module.exports = { foo, bar, Baz }

test/fixtures/exportsObjectShorthand.cjs

@@ -207,6 +207,49 @@ describe('@knighted/module', () => {
     })
   })
 
+  it('emits idiomatic exports for simple module.exports object literal', async t => {
+    const fixturePath = join(fixtures, 'exportsObjectShorthand.cjs')
+    const result = await transform(fixturePath, {
+      target: 'module',
+    })
+    const outFile = join(fixtures, 'exportsObjectShorthand.mjs')
+
+    t.after(() => {
+      rm(outFile, { force: true })
+    })
+
+    await writeFile(outFile, result)
+
+    assert.ok(!result.includes('__exports'))
+    assert.ok(result.includes('export { foo };'))
+    assert.ok(result.includes('export { bar };'))
+    assert.ok(
+      result.includes('export { Baz };') || result.includes('export const Baz = class'),
+    )
+
+    const mod = await import(pathToFileURL(outFile).href)
+    assert.equal((mod as any).foo, 1)
+    assert.equal((mod as any).bar(), 'bar')
+    const baz = new (mod as any).Baz()
+    assert.equal(baz.value(), 'baz')
+  })
+
+  it('falls back to helper for unsupported object literal keys', async t => {
+    const fixturePath = join(fixtures, 'exportsObjectComputed.cjs')
+    const result = await transform(fixturePath, { target: 'module' })
+    const outFile = join(fixtures, 'exportsObjectComputed.mjs')
+
+    t.after(() => {
+      rm(outFile, { force: true })
+    })
+
+    await writeFile(outFile, result)
+
+    assert.ok(result.includes('__exports'))
+    const mod = await import(pathToFileURL(outFile).href)
+    assert.equal((mod as any).default.x, 1)
+  })
+
   it('rewrites multi-declarator static require to imports when lowering to esm', async t => {
     const fixturePath = join(fixtures, 'requireMulti.cjs')
     const outFile = join(fixtures, 'requireMulti.mjs')
@@ -1006,7 +1049,7 @@ describe('@knighted/module', () => {
     assert.equal(!/\sexports\s/.test(result), true)
     assert.equal(result.indexOf('require.cache'), -1)
     assert.ok(/import\.meta/.test(result))
-    assert.ok(result.indexOf('{}') > -1)
+    assert.ok(result.indexOf('export default {') > -1)
 
     const { status } = spawnSync('node', [outFile], { stdio: 'inherit' })
     assert.equal(status, 0)