Transform type exports to "export type" in order to comply with isolatedModules

.github/workflows/ci.yml

@@ -6,7 +6,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: [14, 18]
+        node: [18, 20]
         os: [ubuntu-latest, windows-latest]
 
     name: Node ${{ matrix.node }} on ${{ matrix.os }}
@@ -24,11 +24,11 @@ jobs:
       # frequently hangs for whatever reason,
       # and we have no platform-specific code anyway…
       - name: upload coverage
-        if: matrix.os == 'ubuntu-latest' && matrix.node == 18
+        if: matrix.os == 'ubuntu-latest' && matrix.node == 20
         timeout-minutes: 1
         continue-on-error: true
         run: bash <(curl -s https://codecov.io/bash) -t ${{secrets.CODECOV_TOKEN}} -B ${{ github.ref }} -f coverage/coverage-final.json
       # test the minimum supported peer dependency version
-      - run: npm install typescript@4.1 rollup@3.0
+      - run: npm install typescript@4.5 rollup@3.0
       # aka `npm test` without the `pretest/build`
       - run: node .build/tests/index.js

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 6.0.0
+
+**Compatibility Notice**:
+
+This release raises the minimum required TypeScript version to **4.5** and the minimum required node.js version to **18**.
+
+**Fixes**:
+
+- Export types with `export { type T }` syntax.
+
 ## 5.3.1
 
 **Fixes**:

package.json

@@ -22,7 +22,7 @@
   },
   "homepage": "https://github.com/Swatinem/rollup-plugin-dts#readme",
   "engines": {
-    "node": ">=v14.21.3"
+    "node": ">=v18.16.0"
   },
   "type": "module",
   "main": "./dist/rollup-plugin-dts.cjs",
@@ -60,7 +60,7 @@
   },
   "peerDependencies": {
     "rollup": "^3.0",
-    "typescript": "^4.1 || ^5.0"
+    "typescript": "^4.5 || ^5.0"
   },
   "optionalDependencies": {
     "@babel/code-frame": "^7.22.5"

src/transform/ExportsFixer.ts

@@ -0,0 +1,149 @@
+import ts from "typescript";
+
+type NamedExport = {
+  localName: string;
+  exportedName: string;
+  kind: 'type' | 'value';
+};
+type ExportDeclaration = {
+  location: {
+    start: number;
+    end: number;
+  };
+  exports: Array<NamedExport>
+}
+
+export class ExportsFixer {
+  private readonly DEBUG = !!(process.env.DTS_EXPORTS_FIXER_DEBUG);
+  constructor(private readonly source: ts.SourceFile) {}
+
+  public fix(): string {
+    const exports = this.findExports();
+    exports.sort((a, b) => a.location.start - b.location.start);
+    return this.getCodeParts(exports).join('');
+  }
+
+  private findExports(): Array<ExportDeclaration> {
+    const { rawExports, values, types} = this.getExportsAndLocals();
+
+    return rawExports.map((rawExport) => {
+      const elements = rawExport.elements.map((e) => {
+        const exportedName = e.name.text;
+        const localName = e.propertyName?.text ?? e.name.text;
+        const kind = types.some(node => node.getText() === localName) && !values.some(node => node.getText() === localName) ? 'type' as const : 'value' as const;
+        return {
+          exportedName,
+          localName,
+          kind
+        }
+      })
+      return {
+        location: {
+          start: rawExport.getStart(),
+          end: rawExport.getEnd(),
+        },
+        exports: elements
+      };
+    });
+  }
+
+  private getExportsAndLocals(statements: Iterable<ts.Node> = this.source.statements) {
+    const rawExports: Array<ts.NamedExports> = [];
+    const values: Array<ts.Identifier> = [];
+    const types: Array<ts.Identifier> = [];
+
+    const recurseInto = (subStatements: Iterable<ts.Node>) => {
+      const { rawExports: subExports, values: subValues, types: subTypes} = this.getExportsAndLocals(subStatements);
+      rawExports.push(...subExports);
+      values.push(...subValues);
+      types.push(...subTypes);
+    };
+
+    for (const statement of statements) {
+      this.DEBUG && console.log(statement.getText(), statement.kind);
+      if (ts.isImportDeclaration(statement)) {
+        continue;
+      }
+      if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+        this.DEBUG && console.log(`${statement.name.getFullText()} is a type`);
+        types.push(statement.name);
+        continue;
+      }
+      if (
+        ts.isEnumDeclaration(statement) ||
+        ts.isFunctionDeclaration(statement) ||
+        ts.isClassDeclaration(statement) ||
+        ts.isVariableStatement(statement)
+      ) {
+        if (ts.isVariableStatement(statement)) {
+          for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name)) {
+              this.DEBUG && console.log(`${declaration.name.getFullText()} is a value (from var statement)`);
+              values.push(declaration.name);
+            }
+          }
+        } else {
+          if (statement.name) {
+            this.DEBUG && console.log(`${statement.name.getFullText()} is a value (from declaration)`);
+            values.push(statement.name);
+          }
+        }
+        continue;
+      }
+      if (ts.isModuleBlock(statement)) {
+        const subStatements = statement.statements;
+        recurseInto(subStatements);
+        continue;
+      }
+      if (ts.isModuleDeclaration(statement)) {
+        recurseInto(statement.getChildren());
+        continue;
+      }
+      if (ts.isExportDeclaration(statement)) {
+        if (statement.moduleSpecifier) {
+          continue;
+        }
+        if (statement.isTypeOnly) {
+          // no fixup neccessary
+          continue;
+        }
+        const exportClause = statement.exportClause;
+        if (!exportClause || !ts.isNamedExports(exportClause)) {
+          continue;
+        }
+        rawExports.push(exportClause);
+        continue;
+      }
+      this.DEBUG && console.log('unhandled statement', statement.getFullText(), statement.kind);
+    }
+    return { rawExports, values, types };
+  }
+
+  private createNamedExport(exportSpec: NamedExport, elideType = false) {
+    return `${!elideType && exportSpec.kind === 'type' ? 'type ' : ''}${exportSpec.localName}${exportSpec.localName === exportSpec.exportedName ? '' : ` as ${exportSpec.exportedName}`}`;
+  }
+
+  private getCodeParts(exports: Array<ExportDeclaration>) {
+    let cursor = 0;
+    const code = this.source.getFullText();
+    const parts: Array<string> = [];
+    for (const exportDeclaration of exports) {
+      const head = code.slice(cursor, exportDeclaration.location.start);
+      if (head.length > 0) {
+        parts.push(head);
+      }
+      parts.push(this.getExportStatement(exportDeclaration));
+
+      cursor = exportDeclaration.location.end;
+    }
+    if (cursor < code.length) {
+      parts.push(code.slice(cursor));
+    }
+    return parts;
+  }
+
+  private getExportStatement(exportDeclaration: ExportDeclaration) {
+    const isTypeOnly = exportDeclaration.exports.every((e) => e.kind === 'type') && exportDeclaration.exports.length > 0;
+    return `${isTypeOnly ? 'type ' : ''}{ ${exportDeclaration.exports.map((exp) => this.createNamedExport(exp, isTypeOnly)).join(', ')} }`
+  }
+}

src/transform/index.ts

@@ -4,6 +4,7 @@ import ts from "typescript";
 import { NamespaceFixer } from "./NamespaceFixer.js";
 import { preProcess } from "./preprocess.js";
 import { convert } from "./Transformer.js";
+import {ExportsFixer} from "./ExportsFixer.js";
 
 function parse(fileName: string, code: string): ts.SourceFile {
   return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true);
@@ -91,8 +92,8 @@ export const transform = () => {
       return { code, ast: converted.ast as any, map: preprocessed.code.generateMap() as any };
     },
 
-    renderChunk(code, chunk, options) {
-      const source = parse(chunk.fileName, code);
+    renderChunk(inputCode, chunk, options) {
+      const source = parse(chunk.fileName, inputCode);
       const fixer = new NamespaceFixer(source);
 
       const typeReferences = new Set<string>();
@@ -120,15 +121,17 @@ export const transform = () => {
         }
       }
 
-      code = writeBlock(Array.from(fileReferences, (ref) => `/// <reference path="${ref}" />`));
+      let code = writeBlock(Array.from(fileReferences, (ref) => `/// <reference path="${ref}" />`));
       code += writeBlock(Array.from(typeReferences, (ref) => `/// <reference types="${ref}" />`));
       code += fixer.fix();
 
       if (!code) {
         code += "\nexport { }";
       }
 
-      return { code, map: { mappings: "" } };
+      const exportsFixer = new ExportsFixer(parse(chunk.fileName, code));
+
+      return { code: exportsFixer.fix(), map: { mappings: "" } };
     },
   } satisfies Plugin;
 };

tests/testcases/call-signature/expected.d.ts

@@ -6,4 +6,4 @@ declare const fn: {
   (arg: string): string;
   staticProp: string;
 };
-export { I, fn };
+export { type I, fn };

tests/testcases/computed-property/expected.d.ts

@@ -10,4 +10,4 @@ type Klass = {
   [0]: C;
   [Dprop]: D;
 };
-export { Klass };
+export type { Klass };

tests/testcases/construct-signature/expected.d.ts

@@ -1,4 +1,4 @@
 interface Foo {
   new (): any;
 }
-export { Foo };
+export type { Foo };

tests/testcases/custom-tsconfig/expected.d.ts

@@ -1,2 +1,2 @@
 interface Foo {}
-export { Foo };
+export type { Foo };

tests/testcases/export-as-namespace/expected.d.ts

@@ -1,2 +1,2 @@
 interface Foo {}
-export { Foo };
+export type { Foo };

tests/testcases/export-default-interface/expected.d.ts

@@ -1,2 +1,2 @@
 interface Foo {}
-export { Foo as default };
+export type { Foo as default };

tests/testcases/export-empty-object/expected.d.ts

@@ -1 +1 @@
-export { }
+export {  }

tests/testcases/export-multiple-vars/expected.d.ts

@@ -9,4 +9,4 @@ declare const options: {
 declare const params: {
   normalize: (inVar: In) => Out;
 };
-export { In, Out, config, options, params };
+export { type In, type Out, config, options, params };

tests/testcases/export-simple-alias/expected.d.ts

@@ -1,3 +1,3 @@
 interface Foo {}
 declare type Bar = Foo;
-export { Bar };
+export type { Bar };

tests/testcases/export-simple-interface/expected.d.ts

@@ -1,2 +1,2 @@
 interface Foo {}
-export { Foo };
+export type { Foo };

tests/testcases/export-star-as/expected.d.ts

@@ -1,8 +1,6 @@
 interface A {}
 type foo_d_A = A;
 declare namespace foo_d {
-  export {
-    foo_d_A as A,
-  };
+  export type { foo_d_A as A };
 }
 export { foo_d as foo };

tests/testcases/export-star/expected.d.ts

@@ -1,3 +1,3 @@
 interface B {}
 declare class A {}
-export { A, B };
+export { A, type B };

tests/testcases/externals-link/expected.d.ts

@@ -2,4 +2,4 @@
  * Container element type usable for mouse/touch functions
  */
 type DragContainerElement = HTMLElement | SVGSVGElement | SVGGElement;
-export { DragContainerElement };
+export type { DragContainerElement };

tests/testcases/externals/expected.d.ts

@@ -10,4 +10,4 @@ export { ReactFragment } from 'react';
  * Container element type usable for mouse/touch functions
  */
 type DragContainerElement = HTMLElement | SVGSVGElement | SVGGElement;
-export { DragContainerElement };
+export type { DragContainerElement };

tests/testcases/generic-extends/expected.d.ts

@@ -3,4 +3,4 @@ type AnimatedProps<T> = T;
 type AnimatedComponent<T extends ElementType> = ForwardRefExoticComponent<
   AnimatedProps<ComponentPropsWithRef<T>>
 >;
-export { AnimatedComponent, AnimatedProps };
+export type { AnimatedComponent, AnimatedProps };

tests/testcases/generics/expected.d.ts

@@ -30,4 +30,4 @@ declare function fn<T = G>(g: T, h: Gen<H>): void;
 declare type TyFn = <T = J>(j: T, k: Gen<K>) => L;
 declare type TyCtor = new <T = M>(m: T, n: Gen<N>) => O;
 interface I2 extends Gen<P> {}
-export { Cl, I1, I2, Ty, TyCtor, TyFn, fn };
+export { Cl, type I1, type I2, type Ty, type TyCtor, type TyFn, fn };

tests/testcases/implements-expression/expected.d.ts

@@ -11,4 +11,4 @@ interface MyComponentProps extends ns.Props<G> {
   bar: string;
 }
 declare class MyComponent extends ns.Component<MyComponentProps> {}
-export { MyComponent, MyComponentProps };
+export { MyComponent, type MyComponentProps };

tests/testcases/import-default-interface/expected.d.ts

@@ -1,3 +1,3 @@
 interface Bar {}
 interface Foo extends Bar {}
-export { Foo };
+export type { Foo };

tests/testcases/import-no-import-clause/expected.d.ts

@@ -1,2 +1,2 @@
 interface Foo {}
-export { Foo };
+export type { Foo };

tests/testcases/import-referenced-interface/expected.d.ts

@@ -2,4 +2,4 @@ interface Bar {}
 interface Foo {
   bar: Bar;
 }
-export { Foo };
+export type { Foo };

tests/testcases/import-renamed/expected.d.ts

@@ -2,4 +2,4 @@ interface Bar {}
 interface Foo {
   bar: Bar;
 }
-export { Foo };
+export type { Foo };

tests/testcases/import-unused-interface/expected.d.ts

@@ -1,2 +1,2 @@
 interface Foo {}
-export { Foo };
+export type { Foo };

tests/testcases/inline-import-external-namespace/expected.d.ts

@@ -3,4 +3,4 @@ interface Foo {
   ns1: foo;
   ns2: typeof foo;
 }
-export { Foo };
+export type { Foo };

tests/testcases/inline-import-generic/expected.d.ts

@@ -4,4 +4,4 @@ interface Bar<T> {
 interface Foo {
   bar: Bar<number>;
 }
-export { Foo };
+export type { Foo };