[Breaking] Remove importOrderGroupNamespaceSpecifiers option (#65)

Ref #22 This removes the `importOrderGroupNamespaceSpecifiers`, and always sort the specifiers (i.e. the option is always turned on). I removed a few tests as well that are no longer useful due to removed options.
IanVS · Apr 24, 2023 · 4711e0b · 4711e0b
1 parent 27f4663
commit 4711e0b
Show file tree

Hide file tree

Showing 17 changed files with 26 additions and 253 deletions.
diff --git a/README.md b/README.md
@@ -31,7 +31,6 @@ Since then more critical features & fixes have been added, and the options have
   - [How does import sort work?](#how-does-import-sort-work)
   - [Options](#options)
     - [`importOrder`](#importorder)
-    - [`importOrderSortSpecifiers`](#importordersortspecifiers)
     - [`importOrderMergeDuplicateImports`](#importordermergeduplicateimports)
     - [`importOrderCombineTypeAndValueImports`](#importordercombinetypeandvalueimports)
     - [`importOrderParserPlugins`](#importorderparserplugins)
@@ -133,7 +132,6 @@ module.exports = {
     importOrderParserPlugins: ['typescript', 'jsx', 'decorators-legacy'],
     importOrderMergeDuplicateImports: true,
     importOrderCombineTypeAndValueImports: true,
-    importOrderSortSpecifiers: true,
 };
 ```
 
@@ -221,26 +219,6 @@ _Note:_ If you want to separate some groups from others, you can add an empty st
 ],
 ```
 
-#### `importOrderSortSpecifiers`
-
-**type**: `boolean`
-
-**default value:** `false`
-
-A boolean value to enable or disable sorting of the specifiers in an import declarations. If enabled, type imports will be sorted after value imports.
-
-Before:
-
-```ts
-import Default, {type Bravo, delta as echo, charlie, type Alpha} from 'source';
-```
-
-After:
-
-```ts
-import Default, {charlie, delta as echo, type Alpha, type Bravo} from 'source';
-```
-
 #### `importOrderMergeDuplicateImports`
 
 **type**: `boolean`

diff --git a/docs/MIGRATION.md b/docs/MIGRATION.md
@@ -8,6 +8,7 @@
 - The `importOrderSeparation` option has been removed.  Use empty quotes in your `importOrder` to control the placement of blank lines.
 - The `importOrderCaseInsensitive` option has been removed, and imports will always be sorted case-insensitive.
 - The `importOrderGroupNamespaceSpecifiers` option has been removed.
+- The `importOrderSortSpecifiers` option has been removed, and specifiers are now always sorted (previous `true` setting)
 
 #### `importOrderSeparation` removed
 

diff --git a/prettier.config.js b/prettier.config.js
@@ -7,5 +7,4 @@ module.exports = {
     semi: true,
     plugins: [require('./lib/src/index.js')],
     importOrder: ['', '<THIRD_PARTY_MODULES>', '', '^[./]'],
-    importOrderSortSpecifiers: true,
 };
diff --git a/src/index.ts b/src/index.ts
@@ -37,12 +37,6 @@ export const options: Record<
         default: [{ value: ['typescript', 'jsx'] }],
         description: 'Provide a list of plugins for special syntax',
     },
-    importOrderSortSpecifiers: {
-        type: 'boolean',
-        category: 'Global',
-        default: false,
-        description: 'Should specifiers be sorted?',
-    },
     importOrderMergeDuplicateImports: {
         type: 'boolean',
         category: 'Global',

diff --git a/src/preprocessors/preprocessor.ts b/src/preprocessors/preprocessor.ts
@@ -13,7 +13,6 @@ export function preprocessor(code: string, options: PrettierOptions): string {
         importOrderParserPlugins,
         importOrder,
         importOrderMergeDuplicateImports,
-        importOrderSortSpecifiers,
     } = options;
 
     let { importOrderCombineTypeAndValueImports } = options;
@@ -68,7 +67,6 @@ export function preprocessor(code: string, options: PrettierOptions): string {
         importOrder,
         importOrderMergeDuplicateImports,
         importOrderCombineTypeAndValueImports,
-        importOrderSortSpecifiers,
     });
 
     return getCodeFromAst({

diff --git a/src/types.ts b/src/types.ts
@@ -37,7 +37,6 @@ export type GetSortedNodes = (
         | 'importOrder'
         | 'importOrderMergeDuplicateImports'
         | 'importOrderCombineTypeAndValueImports'
-        | 'importOrderSortSpecifiers'
     >,
 ) => ImportOrLine[];
 

diff --git a/src/utils/__tests__/get-all-comments-from-nodes.spec.ts b/src/utils/__tests__/get-all-comments-from-nodes.spec.ts
@@ -13,7 +13,6 @@ const getSortedImportNodes = (code: string, options?: ParserOptions) => {
         importOrder: [],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     });
 };
 

diff --git a/src/utils/__tests__/get-code-from-ast.spec.ts b/src/utils/__tests__/get-code-from-ast.spec.ts
@@ -20,7 +20,6 @@ import a from 'a';
         importOrder: [],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     });
     const formatted = getCodeFromAst({
         nodesToOutput: sortedNodes,
@@ -58,7 +57,6 @@ import type {See} from 'c';
         importOrder: [],
         importOrderMergeDuplicateImports: true,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     });
     const formatted = getCodeFromAst({
         nodesToOutput: sortedNodes,

diff --git a/src/utils/__tests__/get-sorted-nodes-by-import-order.spec.ts b/src/utils/__tests__/get-sorted-nodes-by-import-order.spec.ts
@@ -31,7 +31,6 @@ test('it returns all sorted nodes', () => {
         importOrder: ['^[./]'],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
@@ -66,59 +65,8 @@ test('it returns all sorted nodes', () => {
         ['BY'],
         ['c', 'cD'],
         ['g'],
-        ['k', 'kE', 'kB'],
-        ['tC', 'tA', 'tB'],
-        ['x'],
-        ['Xa'],
-        ['XY'],
-        ['z'],
-        ['local'],
-    ]);
-});
-
-test('it returns all sorted nodes case-insensitive', () => {
-    const result = getImportNodes(code);
-    const sorted = getSortedNodesByImportOrder(result, {
-        importOrder: ['^[./]'],
-        importOrderMergeDuplicateImports: false,
-        importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
-    }) as ImportDeclaration[];
-
-    expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
-        'node:fs/promises',
-        'node:url',
-        'path',
-        'a',
-        'Ba',
-        'BY',
-        'c',
-        'g',
-        'k',
-        't',
-        'x',
-        'Xa',
-        'XY',
-        'z',
-        './local',
-    ]);
-    expect(
-        sorted
-            .filter((node) => node.type === 'ImportDeclaration')
-            .map((importDeclaration) =>
-                getSortedNodesModulesNames(importDeclaration.specifiers),
-            ),
-    ).toEqual([
-        ['fs'],
-        ['url'], // `node:url` comes before `path`
-        ['path'],
-        ['a'],
-        ['Ba'],
-        ['BY'],
-        ['c', 'cD'],
-        ['g'],
-        ['k', 'kE', 'kB'],
-        ['tC', 'tA', 'tB'],
+        ['k', 'kB', 'kE'],
+        ['tA', 'tB', 'tC'],
         ['x'],
         ['Xa'],
         ['XY'],
@@ -133,107 +81,6 @@ test('it returns all sorted nodes with sort order', () => {
         importOrder: ['^a$', '^t$', '^k$', '^B', '^[./]'],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
-    }) as ImportDeclaration[];
-    expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
-        'node:fs/promises',
-        'node:url',
-        'path',
-        'c',
-        'g',
-        'x',
-        'Xa',
-        'XY',
-        'z',
-        'a',
-        't',
-        'k',
-        'Ba',
-        'BY',
-        './local',
-    ]);
-    expect(
-        sorted
-            .filter((node) => node.type === 'ImportDeclaration')
-            .map((importDeclaration) =>
-                getSortedNodesModulesNames(importDeclaration.specifiers),
-            ),
-    ).toEqual([
-        ['fs'],
-        ['url'], // `node:url` comes before `path`
-        ['path'],
-        ['c', 'cD'],
-        ['g'],
-        ['x'],
-        ['Xa'],
-        ['XY'],
-        ['z'],
-        ['a'],
-        ['tC', 'tA', 'tB'],
-        ['k', 'kE', 'kB'],
-        ['Ba'],
-        ['BY'],
-        ['local'],
-    ]);
-});
-
-test('it returns all sorted nodes with sort order case-insensitive', () => {
-    const result = getImportNodes(code);
-    const sorted = getSortedNodesByImportOrder(result, {
-        importOrder: ['^a$', '^t$', '^k$', '^B', '^[./]'],
-        importOrderMergeDuplicateImports: false,
-        importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
-    }) as ImportDeclaration[];
-    expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
-        'node:fs/promises',
-        'node:url',
-        'path',
-        'c',
-        'g',
-        'x',
-        'Xa',
-        'XY',
-        'z',
-        'a',
-        't',
-        'k',
-        'Ba',
-        'BY',
-        './local',
-    ]);
-    expect(
-        sorted
-            .filter((node) => node.type === 'ImportDeclaration')
-            .map((importDeclaration) =>
-                getSortedNodesModulesNames(importDeclaration.specifiers),
-            ),
-    ).toEqual([
-        ['fs'],
-        ['url'], // `node:url` comes before `path`
-        ['path'],
-        ['c', 'cD'],
-        ['g'],
-        ['x'],
-        ['Xa'],
-        ['XY'],
-        ['z'],
-        ['a'],
-        ['tC', 'tA', 'tB'],
-        ['k', 'kE', 'kB'],
-        ['Ba'],
-        ['BY'],
-        ['local'],
-    ]);
-});
-
-test('it returns all sorted import nodes with sorted import specifiers', () => {
-    const result = getImportNodes(code);
-    const sorted = getSortedNodesByImportOrder(result, {
-        importOrder: ['^a$', '^t$', '^k$', '^B', '^[./]'],
-        importOrderMergeDuplicateImports: false,
-        importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: true,
     }) as ImportDeclaration[];
     expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
         'node:fs/promises',
@@ -277,53 +124,32 @@ test('it returns all sorted import nodes with sorted import specifiers', () => {
     ]);
 });
 
-test('it returns all sorted import nodes with sorted import specifiers with case-insensitive ', () => {
-    const result = getImportNodes(code);
+test('it returns all sorted import nodes with sorted import specifiers', () => {
+    const code = `
+import { tC, tA, tB } from 't';
+import k, { kE, kB } from 'k';
+import {type B, A} from 'z';
+`;
+
+    const result = getImportNodes(code, {
+        plugins: ['typescript'],
+    });
     const sorted = getSortedNodesByImportOrder(result, {
-        importOrder: ['^a$', '^t$', '^k$', '^B', '^[./]'],
+        importOrder: ['^[./]'],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: true,
     }) as ImportDeclaration[];
-    expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
-        'node:fs/promises',
-        'node:url',
-        'path',
-        'c',
-        'g',
-        'x',
-        'Xa',
-        'XY',
-        'z',
-        'a',
-        't',
-        'k',
-        'Ba',
-        'BY',
-        './local',
-    ]);
+    expect(getSortedNodesNamesAndNewlines(sorted)).toEqual(['k', 't', 'z']);
     expect(
         sorted
             .filter((node) => node.type === 'ImportDeclaration')
             .map((importDeclaration) =>
                 getSortedNodesModulesNames(importDeclaration.specifiers),
             ),
     ).toEqual([
-        ['fs'],
-        ['url'], // `node:url` comes before `path`
-        ['path'],
-        ['c', 'cD'],
-        ['g'],
-        ['x'],
-        ['Xa'],
-        ['XY'],
-        ['z'],
-        ['a'],
-        ['tA', 'tB', 'tC'],
         ['k', 'kB', 'kE'],
-        ['Ba'],
-        ['BY'],
-        ['local'],
+        ['tA', 'tB', 'tC'],
+        ['A', 'B'],
     ]);
 });
 
@@ -333,7 +159,6 @@ test('it returns all sorted nodes with builtin specifiers at the top', () => {
         importOrder: ['^[./]'],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
@@ -361,7 +186,6 @@ test('it returns all sorted nodes with custom third party modules and builtins a
         importOrder: ['^a$', '<THIRD_PARTY_MODULES>', '^t$', '^k$', '^[./]'],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
         'node:fs/promises',
@@ -395,7 +219,6 @@ test('it returns all sorted nodes with custom separation', () => {
         ],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
         'node:fs/promises',
@@ -432,7 +255,6 @@ test('it does not add multiple custom import separators', () => {
         ],
         importOrderMergeDuplicateImports: false,
         importOrderCombineTypeAndValueImports: false,
-        importOrderSortSpecifiers: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNamesAndNewlines(sorted)).toEqual([
         'node:fs/promises',