feat: support transformation of export outside enum modifier

Author: Fonger

README.md

@@ -148,18 +148,3 @@ export default {
   ],
 };
 ```
-
-# Caveats
-
-Currently, only immediate export const enum works. For example:
-
-```ts
-// The following works
-export const enum WorkingEnum {}
-
-// The following doesn't work
-const enum FailingEnum {}
-export FailEnum;
-```
-
-This may be fixed in future release.

src/transform.ts

@@ -1,27 +1,31 @@
 import ts from 'typescript';
-import { evaluate, getModifier } from './utils';
+import { evaluate, getExportedNamesOfSource, hasModifier } from './utils';
 
 export default function(program: ts.Program, pluginOptions?: unknown) {
   return (ctx: ts.TransformationContext) => {
     return (sourceFile: ts.SourceFile) => {
-      const ambient = sourceFile.isDeclarationFile;
-
       return ts.visitEachChild(sourceFile, visitor, ctx);
 
       function visitor(node: ts.Node): ts.Node {
         if (!ts.isEnumDeclaration(node)) {
           return ts.visitEachChild(node, visitor, ctx);
         }
-        const exportModifier = getModifier(node, ts.SyntaxKind.ExportKeyword);
-        if (!exportModifier) return node;
-        const constModifier = getModifier(node, ts.SyntaxKind.ConstKeyword);
-        if (!constModifier) return node;
 
-        if (ambient) {
+        if (!hasModifier(node, ts.SyntaxKind.ConstKeyword)) {
+          return node;
+        }
+
+        if (!hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+          if (!getExportedNamesOfSource(program, sourceFile).includes(node.name.text)) {
+            return node;
+          }
+        }
+
+        if (sourceFile.isDeclarationFile) {
           return ts.visitEachChild(node, stripConstKeyword, ctx);
         }
 
-        return transformEnum(node, [exportModifier, constModifier]);
+        return transformEnum(node);
       }
     };
   };
@@ -30,7 +34,7 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
     return node.kind === ts.SyntaxKind.ConstKeyword ? undefined : node;
   }
 
-  function transformEnum(node: ts.EnumDeclaration, modifiers: ts.Modifier[]) {
+  function transformEnum(node: ts.EnumDeclaration) {
     const members = node.members;
     const known = new Map<string, number | string>();
     const properties: ts.PropertyAssignment[] = [];
@@ -78,7 +82,7 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
     }
 
     const result = ts.factory.createVariableStatement(
-      modifiers,
+      node.modifiers,
       ts.factory.createVariableDeclarationList(
         [
           ts.factory.createVariableDeclaration(

src/utils.ts

@@ -70,9 +70,28 @@ export function evaluate(
   throw new Error('unexpected evaluation for enum member: ' + expr.getText);
 }
 
-export function getModifier(node: ts.Node, modifier: ts.SyntaxKind) {
+export function hasModifier(node: ts.Node, modifier: ts.SyntaxKind) {
   return (
-    node.modifiers
-    && node.modifiers.find((mod: ts.Modifier) => mod.kind === modifier)
+    node.modifiers?.some((mod: ts.Modifier) => mod.kind === modifier)
   );
 }
+
+const cachedMap = new WeakMap<ts.SourceFile, string[]>();
+export function getExportedNamesOfSource(program: ts.Program, sourceFile: ts.SourceFile) {
+  const cached = cachedMap.get(sourceFile);
+  if (cached) return cached;
+
+  const typeChecker = program.getTypeChecker();
+  const sourceSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+  if (!sourceSymbol) return [];
+
+  const symbols = typeChecker.getExportsOfModule(sourceSymbol).map(s => {
+    if (s.flags & ts.SymbolFlags.Alias) {
+      return typeChecker.getAliasedSymbol(s).name;
+    }
+    return s.name;
+  });
+
+  cachedMap.set(sourceFile, symbols);
+  return symbols;
+}