Alphabetize type, (almost) fixes import-js#2339

Author: aaronadamsCA

src/rules/order.js

@@ -191,7 +191,9 @@ function fixOutOfOrder(context, firstNode, secondNode, order) {
     newCode = newCode + '\n';
   }
 
-  const message = `\`${secondNode.displayName}\` import should occur ${order} import of \`${firstNode.displayName}\``;
+  const firstImport = firstNode.node.importKind === 'type' ? 'type import' : 'import';
+  const secondImport = secondNode.node.importKind === 'type' ? 'type import' : 'import';
+  const message = `\`${secondNode.displayName}\` ${secondImport} should occur ${order} ${firstImport} of \`${firstNode.displayName}\``;
 
   if (order === 'before') {
     context.report({
@@ -240,21 +242,30 @@ function makeOutOfOrderReport(context, imported) {
   reportOutOfOrder(context, imported, outOfOrder, 'before');
 }
 
-function getSorter(ascending) {
-  const multiplier = ascending ? 1 : -1;
+function getSorter(alphabetizeOptions) {
+  const result = alphabetizeOptions.order === 'asc' ? 1 : -1;
+
+  function normalizeCase(value) {
+    return alphabetizeOptions.caseInsensitive ? String(value).toLowerCase() : value;
+  }
 
   return function importsSorter(importA, importB) {
-    let result;
+    const valueA = normalizeCase(importA.value);
+    const valueB = normalizeCase(importB.value);
 
-    if (importA < importB) {
-      result = -1;
-    } else if (importA > importB) {
-      result = 1;
-    } else {
-      result = 0;
+    if (valueA < valueB) {
+      return -result;
+    } else if (valueA > valueB) {
+      return result;
     }
 
-    return result * multiplier;
+    if (importA.node.importKind < importB.node.importKind) {
+      return -result;
+    } else if (importA.node.importKind > importB.node.importKind) {
+      return result;
+    }
+
+    return 0;
   };
 }
 
@@ -268,11 +279,7 @@ function mutateRanksToAlphabetize(imported, alphabetizeOptions) {
   }, {});
 
   const groupRanks = Object.keys(groupedByRanks);
-
-  const sorterFn = getSorter(alphabetizeOptions.order === 'asc');
-  const comparator = alphabetizeOptions.caseInsensitive
-    ? (a, b) => sorterFn(String(a.value).toLowerCase(), String(b.value).toLowerCase())
-    : (a, b) => sorterFn(a.value, b.value);
+  const comparator = getSorter(alphabetizeOptions);
 
   // sort imports locally within their group
   groupRanks.forEach(function (groupRank) {

tests/src/rules/order.js

@@ -2338,11 +2338,11 @@ context('TypeScript', function () {
           // Option alphabetize: {order: 'asc'}
           test({
             code: `
-              import c from 'Bar';
               import type { C } from 'Bar';
+              import c from 'Bar';
               import b from 'bar';
-              import a from 'foo';
               import type { A } from 'foo';
+              import a from 'foo';
 
               import index from './';
             `,
@@ -2486,12 +2486,12 @@ context('TypeScript', function () {
           }),
           test({
             code: `
-              import { serialize, parse, mapFieldErrors } from '@vtaits/form-schema';
               import type { GetFieldSchema } from '@vtaits/form-schema';
-              import { useMemo, useCallback } from 'react';
+              import { serialize, parse, mapFieldErrors } from '@vtaits/form-schema';
               import type { ReactElement, ReactNode } from 'react';
-              import { Form } from 'react-final-form';
+              import { useMemo, useCallback } from 'react';
               import type { FormProps as FinalFormProps } from 'react-final-form';
+              import { Form } from 'react-final-form';
             `,
             ...parserConfig,
             options: [
@@ -2532,11 +2532,11 @@ context('TypeScript', function () {
               import index from './';
             `,
             output: `
-              import c from 'Bar';
               import type { C } from 'Bar';
+              import c from 'Bar';
               import b from 'bar';
-              import a from 'foo';
               import type { A } from 'foo';
+              import a from 'foo';
 
               import index from './';
             `,
@@ -2549,6 +2549,8 @@ context('TypeScript', function () {
             ],
             errors: [
               { message: '`Bar` import should occur before import of `bar`' },
+              { message: '`Bar` type import should occur before import of `bar`' },
+              { message: '`foo` type import should occur before import of `foo`' },
             ],
           }),
           // Option alphabetize: {order: 'desc'}
@@ -2613,7 +2615,7 @@ context('TypeScript', function () {
             ],
             errors: [
               { message: '`Bar` import should occur before import of `bar`' },
-              { message: '`Bar` import should occur before import of `foo`' },
+              { message: '`Bar` type import should occur before type import of `foo`' },
             ],
           }),
           // Option alphabetize: {order: 'desc'} with type group
@@ -2647,7 +2649,7 @@ context('TypeScript', function () {
             ],
             errors: [
               { message: '`bar` import should occur before import of `Bar`' },
-              { message: '`foo` import should occur before import of `Bar`' },
+              { message: '`foo` type import should occur before type import of `Bar`' },
             ],
           }),
           // warns for out of order unassigned imports (warnOnUnassignedImports enabled)
@@ -2730,8 +2732,8 @@ context('TypeScript', function () {
               },
             ],
             errors: [
-              { message: '`fs` import should occur before import of `path`' },
-              { message: '`fs` import should occur before import of `path`' },
+              { message: '`fs` type import should occur before type import of `path`' },
+              { message: '`fs` type import should occur before type import of `path`' },
             ],
           }),
         ],