Merge pull request #1 from Fonger/feat/sourcemap

feat: support SourceMap mapping

Author: Fonger

.codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 80%
+    patch:
+      default:
+        target: 80%

.github/workflows/test.yml

@@ -25,4 +25,5 @@ jobs:
     - name: Upload coverage report to Codecov
       uses: codecov/[email protected]
       with:
+        files: coverage/lcov.info
         fail_ci_if_error: true

jest.config.js

@@ -8,4 +8,5 @@ module.exports = {
     },
   },
   testPathIgnorePatterns: ['dist'],
+  coverageReporters: ['text', process.env.CI === 'true' ? 'lcovonly' : 'lcov'],
 };

src/__snapshots__/transform.test.ts.snap

@@ -21,10 +21,12 @@ export declare enum ComputedEnum {
     J = \\"12\\",
     K = 1
 }
-export declare enum RegularEnum {
+declare enum NonExportEnum {
     A = 0,
     B = 1
 }
+declare function SomeFunc(inlineSomeEnum: SomeEnum, inlineComputedEnum: ComputedEnum): SomeEnum.D | ComputedEnum | NonExportEnum;
+export default SomeFunc;
 "
 `;
 
@@ -49,10 +51,21 @@ export const ComputedEnum = {
     J: \\"12\\",
     K: 1
 };
-export var RegularEnum;
-(function (RegularEnum) {
-    RegularEnum[RegularEnum[\\"A\\"] = 0] = \\"A\\";
-    RegularEnum[RegularEnum[\\"B\\"] = 1] = \\"B\\";
-})(RegularEnum || (RegularEnum = {}));
-"
+const Value = 0.5;
+var NonExportEnum;
+(function (NonExportEnum) {
+    NonExportEnum[NonExportEnum[\\"A\\"] = 0] = \\"A\\";
+    NonExportEnum[NonExportEnum[\\"B\\"] = 1] = \\"B\\";
+})(NonExportEnum || (NonExportEnum = {}));
+function SomeFunc(inlineSomeEnum, inlineComputedEnum) {
+    if (inlineSomeEnum === 0 /* A */)
+        return 1000 /* D */;
+    if (inlineComputedEnum === -2 /* D */)
+        return 4 /* E */;
+    return Math.random() > Value ? NonExportEnum.A : NonExportEnum.B;
+}
+export default SomeFunc;
+//# 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,KAAK,GAAG,GAAG,CAAC;AAElB,IAAK,aAGJ;AAHD,WAAK,aAAa;IAChB,2CAAC,CAAA;IACD,2CAAC,CAAA;AACH,CAAC,EAHI,aAAa,KAAb,aAAa,QAGjB;AAED,SAAS,QAAQ,CAAC,cAAwB,EAAE,kBAAgC;IAC1E,IAAI,cAAc,cAAe;QAAE,oBAAkB;IACrD,IAAI,kBAAkB,eAAmB;QAAE,iBAAsB;IACjE,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;AACnE,CAAC;AAED,eAAe,QAAQ,CAAC\\"}"`;

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)
   );
 }

test-case/const-enum.ts

@@ -20,7 +20,17 @@ export const enum ComputedEnum {
   K = B & 1000 + H / 2,
 }
 
-export enum RegularEnum {
+const Value = 0.5;
+
+enum NonExportEnum {
   A,
   B,
 }
+
+function SomeFunc(inlineSomeEnum: SomeEnum, inlineComputedEnum: ComputedEnum) {
+  if (inlineSomeEnum === SomeEnum.A) return SomeEnum.D;
+  if (inlineComputedEnum === ComputedEnum.D) return ComputedEnum.E;
+  return Math.random() > Value ? NonExportEnum.A : NonExportEnum.B;
+}
+
+export default SomeFunc;