fix: generate single entry function declaration from TypeScript named…

… export fix #172
fossamagna · Sep 8, 2020 · e0c8a2c · e0c8a2c
1 parent 075a806
commit e0c8a2c
Show file tree

Hide file tree

Showing 2 changed files with 56 additions and 17 deletions.
diff --git a/index.js b/index.js
@@ -36,45 +36,87 @@ function createStubFunctionASTNode(functionName, leadingComments, params) {
   return node;
 }
 
+class EntryPointFunctions {
+  constructor() {
+    this.stubs = new Map();
+    this.functionNames = [];
+  }
+
+  add(functionName, params, comments) {
+    let index = this.functionNames.indexOf(functionName);
+    if (index === -1) {
+      index = this.functionNames.push(functionName) - 1;
+    }
+    this.stubs.set(index, createStubFunctionASTNode(functionName, comments, params));
+  }
+
+  getEntryPointFunctions() {
+    const entryPointFunctions = [];
+    for (let index = 0; index < this.functionNames.length; index++) {
+      entryPointFunctions.push(this.stubs.get(index));
+    }
+    return entryPointFunctions;
+  }
+}
+
+class GlobalAssignments {
+  constructor() {
+    this.stubs = [];
+    this.functionNames = new Set();
+  }
+
+  add(functionName) {
+    if (this.functionNames.has(functionName)) {
+      return;
+    }
+    this.functionNames.add(functionName);
+    this.stubs.push(createGlobalAssignmentASTNode(functionName));
+  }
+
+  getGlobalAssignments() {
+    return this.stubs;
+  }
+}
+
 function _generateStubs(ast, options) {
   const autoGlobalExports = options.autoGlobalExports;
-  const stubs = [];
+  const entryPointFunctions = new EntryPointFunctions();
   estraverse.traverse(ast, {
     leave: function (node) {
       if (node.type === 'ExpressionStatement'
         && isGlobalAssignmentExpression(node.expression)) {
         const functionName = node.expression.left.property.name;
-        stubs.push(createStubFunctionASTNode(functionName, node.leadingComments, node.expression.right.params));
+        entryPointFunctions.add(functionName, node.expression.right.params, node.leadingComments);
       } else if (node.type === 'ExpressionStatement' 
         && node.expression.type === 'SequenceExpression') {
         node.expression.expressions.forEach(function (expression) {
           if (isGlobalAssignmentExpression(expression)) {
             const functionName = expression.left.property.name;
-            stubs.push(createStubFunctionASTNode(functionName, expression.leadingComments ?
-              expression.leadingComments : node.leadingComments, expression.right.params));
+            entryPointFunctions.add(functionName, expression.right.params, expression.leadingComments ?
+              expression.leadingComments : node.leadingComments);
           }
         });
       }
       if (autoGlobalExports) {
         if (node.type === 'ExpressionStatement'
           && isExportsAssignmentExpression(node.expression)) {
             const functionName = node.expression.left.property.name;
-            stubs.push(createStubFunctionASTNode(functionName, node.leadingComments, node.expression.right.params));
+            entryPointFunctions.add(functionName, node.expression.right.params, node.leadingComments);
         } else if (node.type === 'ExpressionStatement' 
           && node.expression.type === 'SequenceExpression') {
           node.expression.expressions.forEach(function (expression) {
             if (isExportsAssignmentExpression(expression)) {
               const functionName = expression.left.property.name;
-              stubs.push(createStubFunctionASTNode(functionName, expression.leadingComments ?
-                expression.leadingComments : node.leadingComments, expression.right.params));
+              entryPointFunctions.add(functionName, expression.right.params, expression.leadingComments ?
+                expression.leadingComments : node.leadingComments);
             }
           });
         }
       }
     }
   });
 
-  return stubs;
+  return entryPointFunctions.getEntryPointFunctions();
 }
 
 function isGlobalAssignmentExpression(node) {
@@ -96,35 +138,31 @@ function isExportsAssignmentExpression(node) {
 function generateStubs(ast, options) {
   const baseAST = createBaseAST();
   const stubs = _generateStubs(ast, options);
-  stubs.forEach(function (stub) {
-    baseAST.body.push(stub);
-  });
+  baseAST.body.push(...stubs);
   return escodegen.generate(baseAST, { comment: !!options.comment });
 }
 
 function generateGlobalAssignments(ast) {
-  const stubs = [];
+  const globalAssignments = new GlobalAssignments();
   estraverse.traverse(ast, {
     leave: (node) => {
       if (node.type === 'ExpressionStatement'
         && isExportsAssignmentExpression(node.expression)) {
           const functionName = node.expression.left.property.name;
-          stubs.push(createGlobalAssignmentASTNode(functionName));
+          globalAssignments.add(functionName);
       } else if (node.type === 'ExpressionStatement' 
         && node.expression.type === 'SequenceExpression') {
         node.expression.expressions.forEach(function (expression) {
           if (isExportsAssignmentExpression(expression)) {
             const functionName = expression.left.property.name;
-            stubs.push(createGlobalAssignmentASTNode(functionName));
+            globalAssignments.add(functionName);
           }
         });
       }
     }
   });
   const baseAST = createBaseAST();
-  stubs.forEach(function (stub) {
-    baseAST.body.push(stub);
-  });
+  baseAST.body.push(...globalAssignments.getGlobalAssignments());
   return escodegen.generate(baseAST);
 }
 

diff --git a/test/fixtures/exports-source.js b/test/fixtures/exports-source.js
@@ -3,6 +3,7 @@
  */
 exports.foo = function() {}
 
+exports.boo = void 0;
 /**
  * This is boo.
  */