feat: support SourceMap mapping

Author: Fonger

src/__snapshots__/transform.test.ts.snap

@@ -54,5 +54,7 @@ export var RegularEnum;
     RegularEnum[RegularEnum[\\"A\\"] = 0] = \\"A\\";
     RegularEnum[RegularEnum[\\"B\\"] = 1] = \\"B\\";
 })(RegularEnum || (RegularEnum = {}));
-"
+//# sourceMappingURL=const-enum.js.map"
 `;
+
+exports[`transform export const enum into object literal test-case/const-enum.js.map 1`] = `"{\\"version\\":3,\\"file\\":\\"const-enum.js\\",\\"sourceRoot\\":\\"\\",\\"sources\\":[\\"const-enum.ts\\"],\\"names\\":[],\\"mappings\\":\\"AAAA,MAAM,OAAY,QAAQ;IACxB,IAAC;IACD,IAAC;IACD,UAAW;IACX,OAAQ;IACR,OAAC;EACF;AAED,MAAM,OAAY,YAAY;IAC5B,IAAC;IACD,IAAC;IACD,IAAC;IACD,KAAU;IACV,IAAU;IACV,KAAc;IACd,OAAuB;IACvB,KAA4B;IAC5B,MAAgB;IAChB,OAAa;IACb,IAAoB;EACrB;AAED,MAAM,CAAN,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,uCAAC,CAAA;IACD,uCAAC,CAAA;AACH,CAAC,EAHW,WAAW,KAAX,WAAW,QAGtB\\"}"`;

src/transform.test.ts

@@ -1,6 +1,5 @@
 import ts from 'typescript';
 import transform from './transform';
-
 describe('transform export const enum into object literal', () => {
   const output = compile('test-case/const-enum.ts');
 
@@ -20,6 +19,7 @@ function compile(fileName: string): Output {
       module: ts.ModuleKind.ES2015,
       preserveConstEnums: true,
       declaration: true,
+      sourceMap: true,
       moduleResolution: ts.ModuleResolutionKind.NodeJs,
     },
   });

src/transform.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { evaluate, hasModifier } from './utils';
+import { evaluate, getModifier } from './utils';
 
 export default function(program: ts.Program, pluginOptions?: unknown) {
   return (ctx: ts.TransformationContext) => {
@@ -12,18 +12,16 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
         if (!ts.isEnumDeclaration(node)) {
           return ts.visitEachChild(node, visitor, ctx);
         }
-        if (
-          !hasModifier(node, ts.SyntaxKind.ExportKeyword)
-          || !hasModifier(node, ts.SyntaxKind.ConstKeyword)
-        ) {
-          return node;
-        }
+        const exportModifier = getModifier(node, ts.SyntaxKind.ExportKeyword);
+        if (!exportModifier) return node;
+        const constModifier = getModifier(node, ts.SyntaxKind.ConstKeyword);
+        if (!constModifier) return node;
 
         if (ambient) {
           return ts.visitEachChild(node, stripConstKeyword, ctx);
         }
 
-        return transformEnum(node);
+        return transformEnum(node, [exportModifier, constModifier]);
       }
     };
   };
@@ -32,10 +30,10 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
     return node.kind === ts.SyntaxKind.ConstKeyword ? undefined : node;
   }
 
-  function transformEnum(node: ts.EnumDeclaration) {
+  function transformEnum(node: ts.EnumDeclaration, modifiers: ts.Modifier[]) {
     const members = node.members;
     const known = new Map<string, number | string>();
-    const ast = [];
+    const properties: ts.PropertyAssignment[] = [];
     let lastValue: string | number = -1;
 
     for (const member of members) {
@@ -44,19 +42,18 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
       }
       const name = member.name.getText();
       let value: string | number;
+      let valueExpr: ts.Expression;
 
       if (member.initializer) {
         value = evaluate(member.initializer, known);
-        let valueExpr: ts.Expression;
+
         if (typeof value === 'number') {
           valueExpr = ts.factory.createNumericLiteral(value);
           lastValue = value;
         } else if (typeof value === 'string') {
           valueExpr = ts.factory.createStringLiteral(value);
           lastValue = value;
         } else throw new Error('Unsupported member value');
-
-        ast.push(ts.factory.createPropertyAssignment(name, valueExpr));
       } else {
         if (typeof lastValue === 'string') {
           throw new Error('Invalid enum');
@@ -72,29 +69,24 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
          * }
          */
         value = ++lastValue;
-        ast.push(
-          ts.factory.createPropertyAssignment(
-            name,
-            ts.factory.createNumericLiteral(value),
-          ),
-        );
+        valueExpr = ts.factory.createNumericLiteral(value);
       }
+      const assignment = ts.factory.createPropertyAssignment(name, valueExpr);
+      ts.setSourceMapRange(assignment, ts.getSourceMapRange(member));
+      properties.push(assignment);
       known.set(name, value);
     }
 
-    return ts.factory.createVariableStatement(
-      [
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-        ts.factory.createModifier(ts.SyntaxKind.ConstKeyword),
-      ],
+    const result = ts.factory.createVariableStatement(
+      modifiers,
       ts.factory.createVariableDeclarationList(
         [
           ts.factory.createVariableDeclaration(
             node.name,
             undefined,
             undefined,
             ts.factory.createAsExpression(
-              ts.factory.createObjectLiteralExpression(ast, true),
+              ts.factory.createObjectLiteralExpression(properties, true),
               ts.factory.createTypeReferenceNode(
                 ts.factory.createIdentifier('const'),
                 undefined,
@@ -105,5 +97,8 @@ export default function(program: ts.Program, pluginOptions?: unknown) {
         ts.NodeFlags.Const,
       ),
     );
+
+    ts.setSourceMapRange(result, ts.getSourceMapRange(node));
+    return result;
   }
 }

src/utils.ts

@@ -69,9 +69,9 @@ export function evaluate(
   return undefined;
 }
 
-export function hasModifier(node: ts.Node, modifier: ts.SyntaxKind): boolean {
+export function getModifier(node: ts.Node, modifier: ts.SyntaxKind) {
   return (
     node.modifiers
-    && node.modifiers.some((mod: ts.Modifier) => mod.kind === modifier)
+    && node.modifiers.find((mod: ts.Modifier) => mod.kind === modifier)
   );
 }