fix: only-type imports

Author: sxzz

package.json

@@ -91,6 +91,7 @@
   },
   "dependencies": {
     "@rollup/pluginutils": "^5.1.0",
+    "oxc-parser": "^0.25.0",
     "oxc-transform": "^0.24.3",
     "unplugin": "^1.12.2"
   },
@@ -104,7 +105,9 @@
     "eslint": "^9.9.0",
     "fast-glob": "^3.3.2",
     "prettier": "^3.3.3",
+    "rolldown": "nightly",
     "rollup": "^4.21.0",
+    "rollup-plugin-esbuild": "^6.1.1",
     "tsdown": "^0.2.6",
     "tsx": "^4.17.0",
     "typescript": "^5.5.4",

pnpm-lock.yaml

@@ -1,20 +1,26 @@
-import { mkdir, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { createFilter } from '@rollup/pluginutils'
-import { createUnplugin, type UnpluginInstance } from 'unplugin'
+import { parseAsync } from 'oxc-parser'
+import {
+  createUnplugin,
+  type UnpluginBuildContext,
+  type UnpluginContext,
+  type UnpluginInstance,
+} from 'unplugin'
 import { resolveOptions, type Options } from './core/options'
 import {
   oxcTransform,
   swcTransform,
   tsTransform,
   type TransformResult,
 } from './core/transformer'
-import type { Plugin } from 'rollup'
+import type { Plugin, PluginContext } from 'rollup'
 
 export type { Options }
 
 export const IsolatedDecl: UnpluginInstance<Options | undefined, false> =
-  createUnplugin((rawOptions = {}) => {
+  createUnplugin((rawOptions = {}, meta) => {
     const options = resolveOptions(rawOptions)
     const filter = createFilter(options.include, options.exclude)
 
@@ -61,32 +67,8 @@ export const IsolatedDecl: UnpluginInstance<Options | undefined, false> =
         return filter(id)
       },
 
-      async transform(code, id): Promise<undefined> {
-        let result: TransformResult
-        switch (options.transformer) {
-          case 'oxc':
-            result = oxcTransform(id, code)
-            break
-          case 'swc':
-            result = await swcTransform(id, code)
-            break
-          case 'typescript':
-            result = await tsTransform(
-              id,
-              code,
-              (options as any).transformOptions,
-            )
-        }
-        const { sourceText, errors } = result
-        if (errors.length) {
-          if (options.ignoreErrors) {
-            this.warn(errors[0])
-          } else {
-            this.error(errors[0])
-            return
-          }
-        }
-        addOutput(id, sourceText)
+      transform(code, id): Promise<undefined> {
+        return transform.call(this, code, id)
       },
 
       esbuild: {
@@ -155,6 +137,80 @@ export const IsolatedDecl: UnpluginInstance<Options | undefined, false> =
         ...rollup,
       },
     }
+
+    async function transform(
+      this: UnpluginBuildContext & UnpluginContext,
+      code: string,
+      id: string,
+    ): Promise<undefined> {
+      let result: TransformResult
+      switch (options.transformer) {
+        case 'oxc':
+          result = oxcTransform(id, code)
+          break
+        case 'swc':
+          result = await swcTransform(id, code)
+          break
+        case 'typescript':
+          result = await tsTransform(
+            id,
+            code,
+            (options as any).transformOptions,
+          )
+      }
+      const { sourceText, errors } = result
+      if (errors.length) {
+        if (options.ignoreErrors) {
+          this.warn(errors[0])
+        } else {
+          this.error(errors[0])
+          return
+        }
+      }
+      addOutput(id, sourceText)
+
+      let program: any
+      try {
+        program = JSON.parse(
+          (await parseAsync(code, { sourceFilename: id })).program,
+        )
+      } catch {
+        return
+      }
+      const typeImports = program.body.filter((node: any) => {
+        if (node.type !== 'ImportDeclaration') return false
+        if (node.importKind === 'type') return true
+        return (node.specifiers || []).every(
+          (spec: any) =>
+            spec.type === 'ImportSpecifier' && spec.importKind === 'type',
+        )
+      })
+
+      const resolve = async (id: string, importer: string) => {
+        if (meta.framework === 'esbuild') {
+          return (
+            await meta.build!.resolve(id, {
+              importer,
+              resolveDir: path.dirname(importer),
+              kind: 'import-statement',
+            })
+          ).path
+        }
+        return (await (this as any as PluginContext).resolve(id, importer))?.id
+      }
+      for (const i of typeImports) {
+        const resolved = await resolve(i.source.value, id)
+        if (resolved) {
+          let source: string
+          try {
+            source = await readFile(resolved, 'utf8')
+          } catch {
+            continue
+          }
+          transform.call(this, source, resolved)
+        }
+      }
+    }
   })
 
 function lowestCommonAncestor(...filepaths: string[]) {

src/index.ts

@@ -1,13 +1,48 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`esbuild > generate mode 1`] = `
-"export type Str = string;
+[
+  "// <stdout>
+// tests/fixtures/main.ts
+function hello(s) {
+  return "hello" + s;
+}
+var num = 1;
+export {
+  hello,
+  num
+};
+",
+  "// main.d.ts
+import { type Num } from "./types";
+export type Str = string;
 export declare function hello(s: Str): Str;
-"
+export declare let num: Num;
+",
+  "// types.d.ts
+export type Num = number;
+",
+]
 `;
 
 exports[`esbuild > write mode 1`] = `
-"export type Str = string;
+[
+  "import { type Num } from "./types";
+export type Str = string;
 export declare function hello(s: Str): Str;
-"
+export declare let num: Num;
+",
+  "// tests/fixtures/main.ts
+function hello(s) {
+  return "hello" + s;
+}
+var num = 1;
+export {
+  hello,
+  num
+};
+",
+  "export type Num = number;
+",
+]
 `;

tests/__snapshots__/esbuild.test.ts.snap

@@ -0,0 +1,25 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`rolldown 1`] = `
+[
+  "// main.d.ts
+import { type Num } from "./types";
+export type Str = string;
+export declare function hello(s: Str): Str;
+export declare let num: Num;
+",
+  "// main.js
+
+//#region tests/fixtures/main.ts
+function hello(s) {
+	return "hello" + s;
+}
+let num = 1;
+
+//#endregion
+export { hello, num };",
+  "// types.d.ts
+export type Num = number;
+",
+]
+`;

tests/__snapshots__/rolldown.test.ts.snap

@@ -3,11 +3,21 @@
 exports[`rollup 1`] = `
 [
   "// main.js
+function hello(s) {
+  return "hello" + s;
+}
+let num = 1;
 
+export { hello, num };
 ",
   "// main.d.ts
+import { type Num } from "./types";
 export type Str = string;
 export declare function hello(s: Str): Str;
+export declare let num: Num;
+",
+  "// types.d.ts
+export type Num = number;
 ",
 ]
 `;

tests/__snapshots__/rollup.test.ts.snap

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises'
+import { readdir, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { build } from 'esbuild'
 import { describe, expect, test } from 'vitest'
@@ -18,11 +18,15 @@ describe('esbuild', () => {
       external: Object.keys(dependencies),
       platform: 'node',
       outdir: dist,
+      format: 'esm',
     })
-
-    expect(
-      await readFile(path.resolve(dist, 'main.d.ts'), 'utf8'),
-    ).toMatchSnapshot()
+    await expect(
+      Promise.all(
+        (await readdir(dist))
+          .sort()
+          .map((file) => readFile(path.resolve(dist, file), 'utf8')),
+      ),
+    ).resolves.toMatchSnapshot()
   })
 
   test('generate mode', async () => {
@@ -34,8 +38,11 @@ describe('esbuild', () => {
       external: Object.keys(dependencies),
       platform: 'node',
       write: false,
+      format: 'esm',
     })
 
-    expect(outputFiles[1].text).toMatchSnapshot()
+    expect(
+      outputFiles.map((file) => `// ${file.path}\n${file.text}`),
+    ).toMatchSnapshot()
   })
 })

tests/esbuild.test.ts

@@ -1,5 +1,8 @@
+import { type Num } from './types'
 export type Str = string
 
 export function hello(s: Str): Str {
   return 'hello' + s
 }
+
+export let num: Num = 1

tests/fixtures/main.ts

@@ -0,0 +1 @@
+export type Num = number

tests/fixtures/types.ts

@@ -0,0 +1,27 @@
+import path from 'node:path'
+import { rolldown } from 'rolldown'
+import { expect, test } from 'vitest'
+import UnpluginIsolatedDecl from '../src/rolldown'
+
+test('rolldown', async () => {
+  const input = path.resolve(__dirname, 'fixtures/main.ts')
+  const dist = path.resolve(__dirname, 'temp')
+
+  const bundle = await rolldown({
+    input,
+    plugins: [UnpluginIsolatedDecl()],
+    logLevel: 'silent',
+  })
+
+  const result = await bundle.generate({
+    dir: dist,
+  })
+  expect(
+    result.output
+      .sort((a, b) => a.fileName.localeCompare(b.fileName))
+      .map(
+        (asset) =>
+          `// ${asset.fileName}\n${asset.type === 'chunk' ? asset.code : asset.source}`,
+      ),
+  ).toMatchSnapshot()
+})