[New] add support for sorting exports.{…} assignments

Author: manuth

Diff for: src/rules/order.js

@@ -8,6 +8,12 @@ import importType from '../core/importType';
 import isStaticRequire from '../core/staticRequire';
 import docsUrl from '../docsUrl';
 
+const categories = {
+  named: 'named',
+  import: 'import',
+  exports: 'exports',
+};
+
 const defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index'];
 
 // REPORTING AND FIXING
@@ -169,16 +175,38 @@ function isPlainImportEquals(node) {
   return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression;
 }
 
-function isModuleExports(node) {
-  return node.parent.parent.type === 'Program'
-    && (
-      node.left.type === 'Identifier'
-      && node.left.name === 'exports')
-    || node.left.type === 'MemberExpression'
-    && node.left.object.type === 'Identifier'
-    && node.left.object.name === 'module'
-    && node.left.property.type === 'Identifier'
-    && node.left.property.name === 'exports';
+function isCJSExports(context, node) {
+  if (node.type === 'MemberExpression'
+      && node.object.type === 'Identifier'
+      && node.property.type === 'Identifier'
+      && node.object.name === 'module'
+      && node.property.name === 'exports') {
+    return context.sourceCode.getScope(node).variables.findIndex((variable) => variable.name === 'module') === -1;
+  } else if (node.type === 'Identifier'
+      && node.name === 'exports') {
+    return context.sourceCode.getScope(node).variables.findIndex((variable) => variable.name === 'exports') === -1;
+  }
+}
+
+function getNamedCJSExports(context, node) {
+  if (node.type !== 'MemberExpression') {
+    return;
+  }
+  const result = [];
+  let root = node;
+  while (root.type === 'MemberExpression') {
+    if (root.property.type !== 'Identifier') {
+      return;
+    }
+    result.unshift(root.property.name);
+    root = root.object;
+  }
+  if (isCJSExports(context, root)) {
+    return result;
+  }
+  if (isCJSExports(context, root.parent)) {
+    return result.slice(1);
+  }
 }
 
 function canCrossNodeWhileReorder(node) {
@@ -216,13 +244,15 @@ function makeImportDescription(node) {
   return 'import';
 }
 
-function fixOutOfOrder(context, firstNode, secondNode, order, named) {
+function fixOutOfOrder(context, firstNode, secondNode, order, category) {
+  const isNamed = category === categories.named;
+  const isExports = category === categories.exports;
   const sourceCode = context.getSourceCode();
 
   const {
     firstRoot,
     secondRoot,
-  } = named ? {
+  } = isNamed ? {
     firstRoot: firstNode.node,
     secondRoot: secondNode.node,
   } : {
@@ -257,7 +287,7 @@ function fixOutOfOrder(context, firstNode, secondNode, order, named) {
     return text.slice(0, i + 1);
   }
 
-  if (named) {
+  if (isNamed) {
     const firstCode = sourceCode.text.substring(firstRootStart, firstRootEnd);
     const secondCode = sourceCode.text.substring(secondRootStart, secondRootEnd);
 
@@ -285,7 +315,7 @@ function fixOutOfOrder(context, firstNode, secondNode, order, named) {
       });
     }
   } else {
-    const canFix = canReorderItems(firstRoot, secondRoot);
+    const canFix = isExports || canReorderItems(firstRoot, secondRoot);
     let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd);
 
     if (newCode[newCode.length - 1] !== '\n') {
@@ -314,16 +344,16 @@ function fixOutOfOrder(context, firstNode, secondNode, order, named) {
   }
 }
 
-function reportOutOfOrder(context, imported, outOfOrder, order, named) {
+function reportOutOfOrder(context, imported, outOfOrder, order, category) {
   outOfOrder.forEach(function (imp) {
     const found = imported.find(function hasHigherRank(importedItem) {
       return importedItem.rank > imp.rank;
     });
-    fixOutOfOrder(context, found, imp, order, named);
+    fixOutOfOrder(context, found, imp, order, category);
   });
 }
 
-function makeOutOfOrderReport(context, imported, named) {
+function makeOutOfOrderReport(context, imported, category) {
   const outOfOrder = findOutOfOrder(imported);
   if (!outOfOrder.length) {
     return;
@@ -333,10 +363,10 @@ function makeOutOfOrderReport(context, imported, named) {
   const reversedImported = reverse(imported);
   const reversedOrder = findOutOfOrder(reversedImported);
   if (reversedOrder.length < outOfOrder.length) {
-    reportOutOfOrder(context, reversedImported, reversedOrder, 'after', named);
+    reportOutOfOrder(context, reversedImported, reversedOrder, 'after', category);
     return;
   }
-  reportOutOfOrder(context, imported, outOfOrder, 'before', named);
+  reportOutOfOrder(context, imported, outOfOrder, 'before', category);
 }
 
 const compareString = (a, b) => {
@@ -810,6 +840,7 @@ module.exports = {
       };
     }
     const importMap = new Map();
+    const exportMap = new Map();
 
     function getBlockImports(node) {
       if (!importMap.has(node)) {
@@ -818,6 +849,13 @@ module.exports = {
       return importMap.get(node);
     }
 
+    function getBlockExports(node) {
+      if (!exportMap.has(node)) {
+        exportMap.set(node, []);
+      }
+      return exportMap.get(node);
+    }
+
     function makeNamedOrderReport(context, namedImports) {
       if (namedImports.length > 1) {
         const imports = namedImports.map(
@@ -837,7 +875,7 @@ module.exports = {
           mutateRanksToAlphabetize(imports, alphabetize);
         }
 
-        makeOutOfOrderReport(context, imports, true);
+        makeOutOfOrderReport(context, imports, categories.named);
       }
     }
 
@@ -964,25 +1002,39 @@ module.exports = {
       } : {},
       ...named.cjsExports && {
         AssignmentExpression: function orderModuleExportNames(node) {
-          if (isModuleExports(node)) {
-            if (node.right.type === 'ObjectExpression') {
-              for (let i = 0; i < node.right.properties.length; i++) {
-                if (node.right.properties[i].key.type !== 'Identifier' || node.right.properties[i].value.type !== 'Identifier') {
-                  return;
+          if (node.parent.type === 'ExpressionStatement') {
+            if (isCJSExports(context, node.left)) {
+              if (node.right.type === 'ObjectExpression') {
+                for (let i = 0; i < node.right.properties.length; i++) {
+                  if (node.right.properties[i].key.type !== 'Identifier' || node.right.properties[i].value.type !== 'Identifier') {
+                    return;
+                  }
                 }
-              }
 
-              makeNamedOrderReport(
-                context,
-                node.right.properties.map(
-                  (prop) => ({
-                    node: prop,
-                    value: prop.key.name,
-                    type: 'export',
-                    ...prop.key.range[0] !== prop.value.range[0] && {
-                      alias: prop.value.name,
-                    },
-                  })));
+                makeNamedOrderReport(
+                  context,
+                  node.right.properties.map(
+                    (prop) => ({
+                      node: prop,
+                      value: prop.key.name,
+                      type: 'export',
+                      ...prop.key.range[0] !== prop.value.range[0] && {
+                        alias: prop.value.name,
+                      },
+                    })));
+              }
+            } else {
+              const nameParts = getNamedCJSExports(context, node.left);
+              if (nameParts && nameParts.length > 0) {
+                const name = nameParts.join('.');
+                getBlockExports(node.parent.parent).push({
+                  node,
+                  value: name,
+                  displayName: name,
+                  type: 'export',
+                  rank: 0,
+                });
+              }
             }
           }
         },
@@ -997,10 +1049,18 @@ module.exports = {
             mutateRanksToAlphabetize(imported, alphabetize);
           }
 
-          makeOutOfOrderReport(context, imported, false);
+          makeOutOfOrderReport(context, imported, categories.import);
+        });
+
+        exportMap.forEach((exported) => {
+          if (alphabetize.order !== 'ignore') {
+            mutateRanksToAlphabetize(exported, alphabetize);
+            makeOutOfOrderReport(context, exported, categories.exports);
+          }
         });
 
         importMap.clear();
+        exportMap.clear();
       },
     };
   },