feat: [import/order] collapse excess spacing for aesthetically pleasi…

…ng imports via `consolidateIslands`

src/rules/order.js

@@ -555,7 +555,17 @@ function computeRank(context, ranks, importEntry, excludedImportTypes, isSorting
 function registerNode(context, importEntry, ranks, imported, excludedImportTypes, isSortingTypesAmongThemselves) {
   const rank = computeRank(context, ranks, importEntry, excludedImportTypes, isSortingTypesAmongThemselves);
   if (rank !== -1) {
-    imported.push({ ...importEntry, rank });
+    let importNode = importEntry.node;
+
+    if(importEntry.type === 'require' && importNode.parent.parent.type === 'VariableDeclaration') {
+      importNode = importNode.parent.parent;
+    }
+
+    imported.push({
+      ...importEntry,
+      rank,
+      isMultiline: importNode.loc.end.line !== importNode.loc.start.line
+    });
   }
 }
 
@@ -681,7 +691,7 @@ function removeNewLineAfterImport(context, currentImport, previousImport) {
   return undefined;
 }
 
-function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, newlinesBetweenTypeOnlyImports, distinctGroup, isSortingTypesAmongThemselves) {
+function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, newlinesBetweenTypeOnlyImports_, distinctGroup, isSortingTypesAmongThemselves, isConsolidatingSpaceBetweenImports) {
   const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {
     const linesBetweenImports = getSourceCode(context).lines.slice(
       previousImport.node.loc.end.line,
@@ -707,51 +717,68 @@ function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, ne
     const isTypeOnlyImport = currentImport.node.importKind === 'type';
     const isPreviousImportTypeOnlyImport = previousImport.node.importKind === 'type';
 
-    const isNormalImportFollowingTypeOnlyImportAndRelevant =
-      !isTypeOnlyImport && isPreviousImportTypeOnlyImport && isSortingTypesAmongThemselves;
+    const isNormalImportNextToTypeOnlyImportAndRelevant =
+      isTypeOnlyImport !== isPreviousImportTypeOnlyImport && isSortingTypesAmongThemselves;
 
     const isTypeOnlyImportAndRelevant =
       isTypeOnlyImport && isSortingTypesAmongThemselves;
 
+    // In the special case where newlinesBetweenTypeOnlyImports and
+    // consolidateIslands want the opposite thing, consolidateIslands wins
+    const newlinesBetweenTypeOnlyImports =
+      newlinesBetweenTypeOnlyImports_ === 'never' &&
+      isConsolidatingSpaceBetweenImports &&
+      isSortingTypesAmongThemselves &&
+      (isNormalImportNextToTypeOnlyImportAndRelevant ||
+        previousImport.isMultiline ||
+        currentImport.isMultiline)
+        ? 'always-and-inside-groups'
+        : newlinesBetweenTypeOnlyImports_;
+
     const isNotIgnored =
       (isTypeOnlyImportAndRelevant &&
         newlinesBetweenTypeOnlyImports !== 'ignore') ||
       (!isTypeOnlyImportAndRelevant && newlinesBetweenImports !== 'ignore');
 
     if(isNotIgnored) {
       const shouldAssertNewlineBetweenGroups =
-        ((isTypeOnlyImportAndRelevant || isNormalImportFollowingTypeOnlyImportAndRelevant) &&
+        ((isTypeOnlyImportAndRelevant || isNormalImportNextToTypeOnlyImportAndRelevant) &&
           (newlinesBetweenTypeOnlyImports === 'always' ||
             newlinesBetweenTypeOnlyImports === 'always-and-inside-groups')) ||
-        ((!isTypeOnlyImportAndRelevant && !isNormalImportFollowingTypeOnlyImportAndRelevant) &&
+        ((!isTypeOnlyImportAndRelevant && !isNormalImportNextToTypeOnlyImportAndRelevant) &&
           (newlinesBetweenImports === 'always' ||
             newlinesBetweenImports === 'always-and-inside-groups'));
 
       const shouldAssertNoNewlineWithinGroup =
-        ((isTypeOnlyImportAndRelevant || isNormalImportFollowingTypeOnlyImportAndRelevant) &&
+        ((isTypeOnlyImportAndRelevant || isNormalImportNextToTypeOnlyImportAndRelevant) &&
           (newlinesBetweenTypeOnlyImports !== 'always-and-inside-groups')) ||
-        ((!isTypeOnlyImportAndRelevant && !isNormalImportFollowingTypeOnlyImportAndRelevant) &&
+        ((!isTypeOnlyImportAndRelevant && !isNormalImportNextToTypeOnlyImportAndRelevant) &&
           (newlinesBetweenImports !== 'always-and-inside-groups'));
 
       const shouldAssertNoNewlineBetweenGroup =
         !isSortingTypesAmongThemselves ||
-        !isNormalImportFollowingTypeOnlyImportAndRelevant ||
+        !isNormalImportNextToTypeOnlyImportAndRelevant ||
         newlinesBetweenTypeOnlyImports === 'never';
 
+      const isTheNewlineBetweenImportsInTheSameGroup = (distinctGroup && currentImport.rank === previousImport.rank) ||
+      (!distinctGroup && !isStartOfDistinctGroup);
+
+      // Let's try to cut down on linting errors sent to the user
+      let alreadyReported = false;
+
       if (shouldAssertNewlineBetweenGroups) {
         if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {
           if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {
+            alreadyReported = true;
             context.report({
               node: previousImport.node,
               message: 'There should be at least one empty line between import groups',
               fix: fixNewLineAfterImport(context, previousImport),
             });
           }
         } else if (emptyLinesBetween > 0 && shouldAssertNoNewlineWithinGroup) {
-          if (
-            (distinctGroup && currentImport.rank === previousImport.rank) ||
-            (!distinctGroup && !isStartOfDistinctGroup)
-          ) {
+          if (isTheNewlineBetweenImportsInTheSameGroup) {
+            alreadyReported = true;
             context.report({
               node: previousImport.node,
               message: 'There should be no empty line within import group',
@@ -760,12 +787,41 @@ function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, ne
           }
         }
       } else if (emptyLinesBetween > 0 && shouldAssertNoNewlineBetweenGroup) {
+        alreadyReported = true;
         context.report({
           node: previousImport.node,
           message: 'There should be no empty line between import groups',
           fix: removeNewLineAfterImport(context, currentImport, previousImport),
         });
       }
+
+      if(!alreadyReported && isConsolidatingSpaceBetweenImports) {
+        if(emptyLinesBetween === 0 && currentImport.isMultiline) {
+          context.report({
+            node: previousImport.node,
+            message: 'There should be at least one empty line between this import and the multi-line import that follows it',
+            fix: fixNewLineAfterImport(context, previousImport),
+          });
+        } else if(emptyLinesBetween === 0 && previousImport.isMultiline) {
+          context.report({
+            node: previousImport.node,
+            message: 'There should be at least one empty line between this multi-line import and the import that follows it',
+            fix: fixNewLineAfterImport(context, previousImport),
+          });
+        } else if (
+          emptyLinesBetween > 0 &&
+          !previousImport.isMultiline &&
+          !currentImport.isMultiline &&
+          isTheNewlineBetweenImportsInTheSameGroup
+        ) {
+          context.report({
+            node: previousImport.node,
+            message:
+              'There should be no empty lines between this single-line import and the single-line import that follows it',
+            fix: removeNewLineAfterImport(context, currentImport, previousImport)
+          });
+        }
+      }
     }
 
     previousImport = currentImport;
@@ -848,6 +904,12 @@ module.exports = {
               'never',
             ],
           },
+          consolidateIslands: {
+            enum: [
+              'inside-groups',
+              'never',
+            ],
+          },
           sortTypesAmongThemselves: {
             type: 'boolean',
             default: false,
@@ -910,6 +972,7 @@ module.exports = {
     const newlinesBetweenTypeOnlyImports = options['newlines-between-types'] || newlinesBetweenImports;
     const pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']);
     const sortTypesAmongThemselves = options.sortTypesAmongThemselves;
+    const consolidateIslands = options.consolidateIslands || 'never';
 
     const named = {
       types: 'mixed',
@@ -1172,7 +1235,17 @@ module.exports = {
       'Program:exit'() {
         importMap.forEach((imported) => {
           if (newlinesBetweenImports !== 'ignore' || newlinesBetweenTypeOnlyImports !== 'ignore') {
-            makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, newlinesBetweenTypeOnlyImports, distinctGroup, isSortingTypesAmongThemselves);
+            makeNewlinesBetweenReport(
+              context,
+              imported,
+              newlinesBetweenImports,
+              newlinesBetweenTypeOnlyImports,
+              distinctGroup,
+              isSortingTypesAmongThemselves,
+              consolidateIslands === 'inside-groups' &&
+                (newlinesBetweenImports === 'always-and-inside-groups' ||
+                  newlinesBetweenTypeOnlyImports === 'always-and-inside-groups')
+            );
           }
 
           if (alphabetize.order !== 'ignore') {