Recognize and respect type-only exports

Resolves #2962

Author: Gerrit0

CHANGELOG.md

@@ -12,6 +12,7 @@ title: Changelog
 
 - Attempting to highlight a supported language which is not enabled is now a warning, not an error, #2956.
 - Improved compatibility with CommonMark's link parsing, #2959.
+- Classes, variables, and functions exported with `export { type X }` are now detected and converted as interfaces/type aliases, #2962.
 
 ## v0.28.5 (2025-05-26)
 

src/lib/converter/context.ts

@@ -190,6 +190,7 @@ export class Context {
         exportSymbol: ts.Symbol | undefined,
     ) {
         if (
+            !reflection.comment &&
             exportSymbol &&
             reflection.kind &
                 (ReflectionKind.SomeModule | ReflectionKind.Reference)

src/lib/converter/symbols.ts

@@ -409,6 +409,42 @@ function convertTypeAlias(
     }
 }
 
+function convertTypeAliasFromValueDeclaration(
+    context: Context,
+    symbol: ts.Symbol,
+    exportSymbol: ts.Symbol | undefined,
+    valueKind: ReflectionKind,
+): undefined {
+    const comment = context.getComment(symbol, valueKind);
+
+    const reflection = new DeclarationReflection(
+        exportSymbol?.name || symbol.name,
+        ReflectionKind.TypeAlias,
+        context.scope,
+    );
+    reflection.comment = comment;
+    context.postReflectionCreation(reflection, symbol, exportSymbol);
+    context.finalizeDeclarationReflection(reflection);
+
+    reflection.type = context.converter.convertType(
+        context.withScope(reflection),
+        context.checker.getTypeOfSymbol(symbol),
+    );
+
+    if (reflection.type.type === "reflection" && reflection.type.declaration.children) {
+        // #2817 lift properties of object literal types up to the reflection level.
+        const typeDecl = reflection.type.declaration;
+        reflection.project.mergeReflections(typeDecl, reflection);
+        delete reflection.type;
+
+        // When created any signatures will be created with __type as their
+        // name, rename them so that they have the alias's name as their name
+        for (const sig of reflection.signatures || []) {
+            sig.name = reflection.name;
+        }
+    }
+}
+
 function attachUnionComments(
     context: Context,
     declaration: ts.TypeAliasDeclaration,
@@ -495,6 +531,10 @@ function convertFunctionOrMethod(
     symbol: ts.Symbol,
     exportSymbol?: ts.Symbol,
 ): undefined | ts.SymbolFlags {
+    if (isTypeOnlyExport(exportSymbol)) {
+        return convertTypeAliasFromValueDeclaration(context, symbol, exportSymbol, ReflectionKind.Function);
+    }
+
     // Can't just check method flag because this might be called for properties as well
     // This will *NOT* be called for variables that look like functions, they need a special case.
     const isMethod = !!(
@@ -573,7 +613,7 @@ function convertClassOrInterface(
     exportSymbol?: ts.Symbol,
 ) {
     const reflection = context.createDeclarationReflection(
-        ts.SymbolFlags.Class & symbol.flags
+        (ts.SymbolFlags.Class & symbol.flags) && !isTypeOnlyExport(exportSymbol)
             ? ReflectionKind.Class
             : ReflectionKind.Interface,
         symbol,
@@ -618,7 +658,7 @@ function convertClassOrInterface(
 
     context.finalizeDeclarationReflection(reflection);
 
-    if (classDeclaration) {
+    if (classDeclaration && reflection.kind === ReflectionKind.Class) {
         // Classes can have static props
         const staticType = context.checker.getTypeOfSymbolAtLocation(
             symbol,
@@ -984,6 +1024,10 @@ function convertVariable(
     symbol: ts.Symbol,
     exportSymbol?: ts.Symbol,
 ): undefined | ts.SymbolFlags {
+    if (isTypeOnlyExport(exportSymbol)) {
+        return convertTypeAliasFromValueDeclaration(context, symbol, exportSymbol, ReflectionKind.Variable);
+    }
+
     const declaration = symbol.getDeclarations()?.[0];
 
     const comment = context.getComment(symbol, ReflectionKind.Variable);
@@ -1485,3 +1529,13 @@ function isFunctionLikeInitializer(node: ts.Expression): boolean {
 
     return false;
 }
+
+function isTypeOnlyExport(symbol: ts.Symbol | undefined): boolean {
+    if (!symbol) return false;
+
+    const declaration = symbol.declarations?.[0];
+    if (!declaration) return false;
+    if (!ts.isExportSpecifier(declaration)) return false;
+
+    return declaration.isTypeOnly || declaration.parent.parent.isTypeOnly;
+}

src/test/converter2/issues/gh2962.ts

@@ -0,0 +1,18 @@
+class Class {
+    msg: string;
+
+    constructor(msg: string) {
+        this.msg = msg;
+    }
+}
+
+const Var = 123;
+
+function Func<T>(a: T) {}
+
+export { type Class, type Func, type Var };
+
+class Class2 {}
+const Var2 = 123;
+function Func2() {}
+export type { Class2, Func2, Var2 };

src/test/issues.c2.test.ts

@@ -2140,4 +2140,20 @@ describe("Issue Tests", () => {
         equal(query(project, "InterfaceA.propertyB").type?.toString(), "AliasB<string>");
         equal(query(project, "InterfaceA.propertyC").type?.toString(), "AliasC");
     });
+
+    it("#2962 handles type-only exports", () => {
+        const project = convert();
+        equal(project.children?.map(c => [c.name, ReflectionKind[c.kind]]), [
+            ["Class", "Interface"],
+            ["Class2", "Interface"],
+            ["Func", "TypeAlias"],
+            ["Func2", "TypeAlias"],
+            ["Var", "TypeAlias"],
+            ["Var2", "TypeAlias"],
+        ]);
+
+        equal(query(project, "Class").children?.map(c => c.name), ["msg"]);
+        equal(query(project, "Func").type?.toString(), "(a: T) => void");
+        equal(query(project, "Var").type?.toString(), "123");
+    });
 });