feat!: remove inputAlias option, enforce use of input option (#12)

Co-authored-by: 三咲智子 Kevin Deng <sxzz@sxzz.moe>

Author: ocavue

README.md

@@ -29,7 +29,7 @@ You can find a real demo in [here](./rolldown.config.ts).
 
 ## Options
 
-````ts
+```ts
 interface Options {
   /**
    * When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
@@ -58,21 +58,11 @@ interface Options {
    * This option is enabled when `isolatedDeclaration` in `tsconfig.json` is set to `true`.
    */
   isolatedDeclaration?: boolean | Omit<IsolatedDeclarationsOptions, 'sourcemap'>
-  /**
-   * dts file name alias `{ [filename]: path }`
-   *
-   * @example
-   * ```ts
-   * inputAlias: {
-   *   'foo.d.ts': 'foo/index.d.ts',
-   * }
-   */
-  inputAlias?: Record<string, string>
 
   /** Resolve external types used in dts files from `node_modules` */
   resolve?: boolean | (string | RegExp)[]
 }
-````
+```
 
 ## Differences from `rollup-plugin-dts`
 

src/generate.ts

@@ -1,4 +1,5 @@
-import { basename, extname } from 'node:path'
+import path from 'node:path'
+import process from 'node:process'
 import { createResolver } from 'dts-resolver'
 import { getTsconfig } from 'get-tsconfig'
 import { isolatedDeclaration as oxcIsolatedDeclaration } from 'oxc-transform'
@@ -25,25 +26,27 @@ const meta = { dtsFile: true } as const
 export function createGeneratePlugin({
   compilerOptions,
   isolatedDeclaration,
-  inputAlias,
   resolve = false,
   emitDtsOnly = false,
 }: Pick<
   Options,
-  | 'isolatedDeclaration'
-  | 'inputAlias'
-  | 'resolve'
-  | 'emitDtsOnly'
-  | 'compilerOptions'
+  'isolatedDeclaration' | 'resolve' | 'emitDtsOnly' | 'compilerOptions'
 >): Plugin {
   const dtsMap = new Map<string, { code: string; src: string }>()
-  const inputAliasMap = new Map<string, string>(
-    inputAlias && Object.entries(inputAlias),
-  )
+
+  /**
+   * A map of input id to output file name
+   *
+   * @example
+   *
+   * inputAlias = new Map([
+   *   ['/absolute/path/to/src/source_file.ts', 'dist/foo/index'],
+   * ])
+   */
+  const inputAliasMap = new Map<string, string>()
   const resolver = createResolver()
   let programs: TsProgram[] = []
 
-  let inputOption: Record<string, string> | undefined
   return {
     name: 'rolldown-plugin-dts:generate',
 
@@ -60,11 +63,13 @@ export function createGeneratePlugin({
       if (!isolatedDeclaration) {
         initTs()
       }
-    },
 
-    options({ input }) {
-      if (isPlainObject(input)) {
-        inputOption = { ...input }
+      if (!Array.isArray(options.input)) {
+        const cwd = options.cwd || process.cwd()
+        for (const [fileName, inputFilePath] of Object.entries(options.input)) {
+          const id = path.resolve(cwd, inputFilePath)
+          inputAliasMap.set(id, fileName)
+        }
       }
     },
 
@@ -138,16 +143,11 @@ export function createGeneratePlugin({
         })
 
         if (isEntry) {
-          let name: string | undefined = basename(dtsId, extname(dtsId))
-          if (inputAliasMap.has(name)) {
-            name = inputAliasMap.get(name)!
-          } else if (inputAliasMap.has(dtsId)) {
-            name = inputAliasMap.get(dtsId)!
-          }
+          const name = inputAliasMap.get(id)
           this.emitFile({
             type: 'chunk',
             id: dtsId,
-            name,
+            name: name ? `${name}.d` : undefined,
           })
 
           if (emitDtsOnly) {
@@ -157,7 +157,7 @@ export function createGeneratePlugin({
       },
     },
 
-    async resolveId(id, importer, extraOptions) {
+    async resolveId(id, importer) {
       // must be entry
       if (dtsMap.has(id)) {
         return { id, meta }
@@ -201,22 +201,6 @@ export function createGeneratePlugin({
         if (dtsMap.has(dtsId)) {
           return { id: dtsId, meta }
         }
-      } else if (extraOptions.isEntry && inputOption) {
-        // mapping entry point to dts filename
-        const resolution = await this.resolve(id, importer, extraOptions)
-        if (!resolution) return
-
-        const dtsId = filename_ts_to_dts(resolution.id)
-        if (inputAliasMap.has(dtsId)) return resolution
-
-        for (const [name, entry] of Object.entries(inputOption)) {
-          if (entry === id) {
-            inputAliasMap.set(dtsId, `${name}.d.ts`)
-            break
-          }
-        }
-
-        return resolution
       }
     },
 
@@ -252,12 +236,3 @@ export function createGeneratePlugin({
     },
   }
 }
-
-function isPlainObject(data: unknown): data is Record<PropertyKey, unknown> {
-  if (typeof data !== 'object' || data === null) {
-    return false
-  }
-
-  const proto = Object.getPrototypeOf(data)
-  return proto === null || proto === Object.prototype
-}

src/index.ts

@@ -31,16 +31,6 @@ export interface Options {
    * This option is enabled when `isolatedDeclaration` in `tsconfig.json` is set to `true`.
    */
   isolatedDeclaration?: boolean | Omit<IsolatedDeclarationsOptions, 'sourcemap'>
-  /**
-   * dts file name alias `{ [filename]: path }`
-   *
-   * @example
-   * ```ts
-   * inputAlias: {
-   *   'foo.d.ts': 'foo/index.d.ts',
-   * }
-   */
-  inputAlias?: Record<string, string>
 
   /** Resolve external types used in dts files from `node_modules` */
   resolve?: boolean | (string | RegExp)[]

tests/__snapshots__/index.test.ts.snap

@@ -1,5 +1,69 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`input alias 1`] = `
+"// input2-eM-jH71Q.js
+
+//#region shared.ts
+const shared = { shared: "shared" };
+
+//#endregion
+//#region input2.ts
+const input2 = {
+	...shared,
+	input2: "input2"
+};
+
+//#endregion
+export { input2 };
+// input2.d-D6mB_nrs.d.ts
+
+//#region shared.d.ts
+interface Shared {
+    shared: string;
+}
+declare const shared: Shared;
+
+//#endregion
+//#region input2.d.ts
+interface Input2 extends Shared {
+    input2: string;
+}
+declare const input2: Input2;
+
+//#endregion
+export { Input2, input2 as input2$1 };
+// output1.d.ts
+import { Input2 } from "./input2.d-D6mB_nrs.js";
+
+//#region input1.d.ts
+interface Input1 extends Input2 {
+    input1: string;
+}
+declare const input1: Input1;
+
+//#endregion
+export { Input1, input1 };
+// output1.js
+import { input2 } from "./input2-eM-jH71Q.js";
+
+//#region input1.ts
+const input1 = {
+	...input2,
+	input1: "input1"
+};
+
+//#endregion
+export { input1 };
+// output2/index.d.ts
+import { Input2, input2$1 as input2 } from "../input2.d-D6mB_nrs.js";
+
+export { Input2, input2 };
+// output2/index.js
+import { input2 } from "../input2-eM-jH71Q.js";
+
+export { input2 };"
+`;
+
 exports[`resolve dependencies 1`] = `
 "// resolve-dep.d.ts
 import MagicString, { MagicStringOptions, OverwriteOptions } from "magic-string";

tests/fixtures/alias/input1.ts

@@ -0,0 +1,10 @@
+import { Input2, input2 } from './input2'
+
+export interface Input1 extends Input2 {
+  input1: string
+}
+
+export const input1: Input1 = {
+  ...input2,
+  input1: 'input1',
+}

tests/fixtures/alias/input2.ts

@@ -0,0 +1,10 @@
+import { Shared, shared } from './shared'
+
+export interface Input2 extends Shared {
+  input2: string
+}
+
+export const input2: Input2 = {
+  ...shared,
+  input2: 'input2',
+}

tests/fixtures/alias/shared.ts

@@ -0,0 +1,7 @@
+export interface Shared {
+  shared: string
+}
+
+export const shared: Shared = {
+  shared: 'shared',
+}

tests/index.test.ts

@@ -38,6 +38,39 @@ test('resolve dependencies', async () => {
   expect(snapshot).toMatchSnapshot()
 })
 
+// Test alias mapping based on rolldown input option
+test('input alias', async () => {
+  const root = path.resolve(dirname, 'fixtures/alias')
+  const { snapshot, chunks } = await rolldownBuild(
+    null!,
+    [
+      dts({
+        emitDtsOnly: false, // Generate both JS and DTS files
+        compilerOptions: {},
+        isolatedDeclaration: false,
+      }),
+    ],
+    {
+      cwd: root,
+      // A mapping from output chunk names to input files. This mapping should
+      // be used in both JS and DTS outputs.
+      input: {
+        output1: 'input1.ts',
+        'output2/index': 'input2.ts',
+      },
+    },
+  )
+  const fileNames = chunks.map((chunk) => chunk.fileName).sort()
+
+  // The JS output and DTS output should have the same structure
+  expect(fileNames).toContain('output1.d.ts')
+  expect(fileNames).toContain('output1.js')
+  expect(fileNames).toContain('output2/index.d.ts')
+  expect(fileNames).toContain('output2/index.js')
+
+  expect(snapshot).toMatchSnapshot()
+})
+
 test('isolated declaration error', async () => {
   const error = await rolldownBuild(
     path.resolve(dirname, 'fixtures/isolated-decl-error.ts'),