Add sort by length option

README.md

@@ -198,6 +198,13 @@ with options as a JSON string of the plugin array:
 importOrderParserPlugins: []
 ```
 
+### `importOrderSortByLength`
+**type**: `'asc' | 'desc' | null`
+**default value**: `null`
+
+A choice value to enable sorting imports within their groups based on their string lengths, the two options being ascending and descending.
+Leaving the value blank or setting it to null will result in length being ignored
+
 ### `importOrderSideEffects`
 **type**: `boolean`
 **default value**: `true`

src/index.ts

@@ -53,6 +53,17 @@ const options: Options = {
         default: false,
         description: 'Should specifiers be sorted?',
     },
+    importOrderSortByLength: {
+        type: 'choice',
+        category: 'Global',
+        default: null,
+        choices: [
+            {value: 'asc', description: 'will sort from shortest to longest'},
+            {value: 'desc', description: 'will sort from longest to shortest'},
+            {value: null, description: 'will disable sorting based on length'}
+        ],
+        description: 'Should imports be sorted by their string length'
+    },
     importOrderSideEffects: {
         type: 'boolean',
         category: 'Global',
@@ -64,7 +75,7 @@ const options: Options = {
         category: 'Global',
         default: 'with',
         description: 'Provide a keyword for import attributes',
-    },
+    }
 };
 
 module.exports = {

src/preprocessors/preprocessor.ts

@@ -16,8 +16,9 @@ export function preprocessor(code: string, options: PrettierOptions) {
         importOrderSeparation,
         importOrderGroupNamespaceSpecifiers,
         importOrderSortSpecifiers,
+        importOrderSortByLength,
         importOrderSideEffects,
-        importOrderImportAttributesKeyword,
+        importOrderImportAttributesKeyword
     } = options;
 
     const parserOptions: ParserOptions = {
@@ -44,7 +45,8 @@ export function preprocessor(code: string, options: PrettierOptions) {
         importOrderSeparation,
         importOrderGroupNamespaceSpecifiers,
         importOrderSortSpecifiers,
-        importOrderSideEffects,
+        importOrderSortByLength,
+        importOrderSideEffects
     });
 
     return getCodeFromAst(allImports, directives, code, interpreter, {

src/types.ts

@@ -19,6 +19,7 @@ export type GetSortedNodes = (
         | 'importOrderSeparation'
         | 'importOrderGroupNamespaceSpecifiers'
         | 'importOrderSortSpecifiers'
+        | 'importOrderSortByLength'
         | 'importOrderSideEffects'
     >,
 ) => ImportOrLine[];

src/utils/__tests__/get-all-comments-from-nodes.spec.ts

@@ -14,7 +14,8 @@ const getSortedImportNodes = (code: string, options?: ParserOptions) => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     });
 };
 

src/utils/__tests__/get-code-from-ast.spec.ts

@@ -25,7 +25,8 @@ import a from 'a';
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     });
     const formatted = getCodeFromAst(sortedNodes, [], code, null);
     expect(await format(formatted, { parser: 'babel' })).toEqual(

src/utils/__tests__/get-import-nodes-matched-group.spec.ts

@@ -1,5 +1,3 @@
-import { THIRD_PARTY_MODULES_SPECIAL_WORD } from '../../constants';
-import { ImportGroups } from '../../types';
 import { getImportNodes } from '../get-import-nodes';
 import { getImportNodesMatchedGroup } from '../get-import-nodes-matched-group';
 

src/utils/__tests__/get-sorted-nodes-by-import-order.spec.ts

@@ -28,6 +28,7 @@ test('it returns all sorted nodes', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 
@@ -73,6 +74,7 @@ test('it returns all sorted nodes case-insensitive', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 
@@ -118,6 +120,7 @@ test('it returns all sorted nodes with sort order', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 
@@ -163,6 +166,7 @@ test('it returns all sorted nodes with sort order case-insensitive', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -207,6 +211,7 @@ test('it returns all sorted import nodes with sorted import specifiers', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: true,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -251,6 +256,7 @@ test('it returns all sorted import nodes with sorted import specifiers with case
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: true,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -295,6 +301,7 @@ test('it returns all sorted nodes with custom third party modules', () => {
         importOrderCaseInsensitive: true,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -320,6 +327,7 @@ test('it returns all sorted nodes with namespace specifiers at the top', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: true,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 

src/utils/__tests__/get-sorted-nodes.spec.ts

@@ -46,7 +46,8 @@ test('it returns all sorted nodes', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -91,7 +92,8 @@ test('it returns all sorted nodes case-insensitive', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -136,7 +138,8 @@ test('it returns all sorted nodes with sort order', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -181,7 +184,8 @@ test('it returns all sorted nodes with sort order case-insensitive', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'c',
@@ -225,7 +229,8 @@ test('it returns all sorted import nodes with sorted import specifiers', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: true,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'XY',
@@ -269,7 +274,8 @@ test('it returns all sorted import nodes with sorted import specifiers with case
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: true,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'c',
@@ -313,7 +319,8 @@ test('it returns all sorted nodes with custom third party modules', () => {
         importOrderCaseInsensitive: true,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'a',
@@ -338,7 +345,8 @@ test('it returns all sorted nodes with namespace specifiers at the top', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: true,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -356,6 +364,58 @@ test('it returns all sorted nodes with namespace specifiers at the top', () => {
     ]);
 });
 
+test('it returns all sorted nodes, sorted shortest to longest', () => {
+    const result = getImportNodes(code)
+    const sorted = getSortedNodes(result, {
+        importOrder: [],
+        importOrderCaseInsensitive: false,
+        importOrderSeparation: false,
+        importOrderGroupNamespaceSpecifiers: false,
+        importOrderSortSpecifiers: false,
+        importOrderSideEffects: true,
+        importOrderSortByLength: 'asc'
+    }) as ImportDeclaration[];
+    expect(getSortedNodesNames(sorted)).toEqual([
+        'g',
+        'z',
+        'Ba',
+        'BY',
+        'Xa',
+        'XY',
+        'a',
+        'x',
+        'c',
+        'k',
+        't',
+    ]);
+});
+
+test('it returns all sorted nodes, sorted longest to shortest', () => {
+    const result = getImportNodes(code)
+    const sorted = getSortedNodes(result, {
+        importOrder: [],
+        importOrderCaseInsensitive: false,
+        importOrderSeparation: false,
+        importOrderGroupNamespaceSpecifiers: false,
+        importOrderSortSpecifiers: false,
+        importOrderSideEffects: false,
+        importOrderSortByLength: 'desc'
+    }) as ImportDeclaration[];
+    expect(getSortedNodesNames(sorted)).toEqual([
+        't',
+        'k',
+        'c',
+        'a',
+        'x',
+        'Ba',
+        'BY',
+        'Xa',
+        'XY',
+        'g',
+        'z'
+    ]);
+});
+
 test('it returns all sorted nodes with types', () => {
     const result = getImportNodes(typeCode, {
         plugins: ['typescript'],
@@ -367,6 +427,7 @@ test('it returns all sorted nodes with types', () => {
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
+        importOrderSortByLength: null,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([

src/utils/__tests__/remove-nodes-from-original-code.spec.ts

@@ -25,7 +25,8 @@ test('it should remove nodes from the original code', async () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
-        importOrderSideEffects: true,
+        importOrderSortByLength: null,
+        importOrderSideEffects: true
     });
     const allCommentsFromImports = getAllCommentsFromNodes(sortedNodes);
 

src/utils/get-sorted-nodes-by-import-order.ts

@@ -17,7 +17,7 @@ import { getSortedNodesGroup } from './get-sorted-nodes-group';
 export const getSortedNodesByImportOrder: GetSortedNodes = (nodes, options) => {
     naturalSort.insensitive = options.importOrderCaseInsensitive;
 
-    let { importOrder } = options;
+    let { importOrder,importOrderSortByLength } = options;
     const {
         importOrderSeparation,
         importOrderSortSpecifiers,
@@ -58,6 +58,7 @@ export const getSortedNodesByImportOrder: GetSortedNodes = (nodes, options) => {
 
         const sortedInsideGroup = getSortedNodesGroup(groupNodes, {
             importOrderGroupNamespaceSpecifiers,
+            importOrderSortByLength
         });
 
         // Sort the import specifiers

src/utils/get-sorted-nodes-group.ts

@@ -1,18 +1,27 @@
-import { Import, ImportDeclaration } from '@babel/types';
+import { ImportDeclaration } from '@babel/types';
 
 import { naturalSort } from '../natural-sort';
 import { PrettierOptions } from '../types';
 
 export const getSortedNodesGroup = (
     imports: ImportDeclaration[],
-    options: Pick<PrettierOptions, 'importOrderGroupNamespaceSpecifiers'>,
+    options: Pick<PrettierOptions, 'importOrderGroupNamespaceSpecifiers' | 'importOrderSortByLength'>,
 ) => {
     return imports.sort((a, b) => {
+        const aLength = (a.end || 0) - (a.start || 0)
+        const bLength = (b.end || 0) - (b.start || 0)
+
         if (options.importOrderGroupNamespaceSpecifiers) {
             const diff = namespaceSpecifierSort(a, b);
             if (diff !== 0) return diff;
         }
 
+        if (options.importOrderSortByLength === 'asc')
+            return aLength - bLength || a.source.value.localeCompare(b.source.value)
+
+        if (options.importOrderSortByLength === 'desc')
+            return bLength - aLength  || a.source.value.localeCompare(b.source.value)
+
         return naturalSort(a.source.value, b.source.value);
     });
 };