Add sort by length option

README.md

@@ -207,6 +207,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`
@@ -310,10 +317,10 @@ debug some code in the plugin, check [Debugging Guidelines](./docs/DEBUG.md)
 
 ### Maintainers
 
-| [Ayush Sharma](https://github.com/ayusharma)                             | [Behrang Yarahmadi](https://github.com/byara)                         |
-| ------------------------------------------------------------------------ | --------------------------------------------------------------------- |
-| ![ayusharma](https://avatars2.githubusercontent.com/u/6918450?s=120&v=4) | ![@byara](https://avatars2.githubusercontent.com/u/6979966?s=120&v=4) |
-| [@ayusharma\_](https://twitter.com/ayusharma_)                           | [@behrang_y](https://twitter.com/behrang_y)                           |
+| [Ayush Sharma](https://github.com/ayusharma)                             | [Behrang Yarahmadi](https://github.com/byara)                         | [Vladislav Arsenev](https://github.com/vladislavarsenev)                 |
+| ------------------------------------------------------------------------ | --------------------------------------------------------------------- |--------------------------------------------------------------------------|
+| ![ayusharma](https://avatars2.githubusercontent.com/u/6918450?s=120&v=4) | ![@byara](https://avatars2.githubusercontent.com/u/6979966?s=120&v=4) |![@vladislavarsenev](https://avatars.githubusercontent.com/u/51095682?s=120&v=4)|
+| [@ayusharma](https://twitter.com/ayusharma_)                             | [@behrang_y](https://twitter.com/behrang_y)                           |                                                                          |
 
 ### Disclaimer
 

src/index.ts

@@ -56,6 +56,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',
@@ -67,7 +78,7 @@ const options: Options = {
         category: 'Global',
         default: 'with',
         description: 'Provide a keyword for import attributes',
-    },
+    }
 };
 
 export default {

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

@@ -15,7 +15,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,7 +1,5 @@
 import { expect, test } from 'vitest'
 
-import { THIRD_PARTY_MODULES_SPECIAL_WORD } from '../../constants.js';
-import { ImportGroups } from '../../types';
 import { getImportNodes } from '../get-import-nodes.js';
 import { getImportNodesMatchedGroup } from '../get-import-nodes-matched-group.js';
 

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

@@ -31,6 +31,7 @@ test('it returns all sorted nodes', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 
@@ -76,6 +77,7 @@ test('it returns all sorted nodes case-insensitive', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 
@@ -121,6 +123,7 @@ test('it returns all sorted nodes with sort order', () => {
         importOrderSeparation: false,
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
+        importOrderSortByLength: null,
         importOrderSideEffects: true,
     }) as ImportDeclaration[];
 
@@ -166,6 +169,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([
@@ -210,6 +214,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([
@@ -254,6 +259,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([
@@ -298,6 +304,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([
@@ -323,6 +330,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[];
 
@@ -350,6 +358,7 @@ test('it returns the default separations if `importOrderSeparation` is false', (
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
+        importOrderSortByLength: null,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: "ImportDeclaration", value: 'XY' },
@@ -376,6 +385,7 @@ test('it returns default import module separations', () => {
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
+        importOrderSortByLength: null,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: "ImportDeclaration", value: 'XY' },
@@ -407,6 +417,7 @@ test('it returns targeted import module separations', () => {
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
+        importOrderSortByLength: null,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: "ImportDeclaration", value: 'XY' },
@@ -437,6 +448,7 @@ test('it never returns a separation at the top of the list (leading separator)',
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
+        importOrderSortByLength: null,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: "ImportDeclaration", value: './test' },
@@ -455,6 +467,7 @@ test('it never returns a separation at the top of the list (zero preceding impor
         importOrderGroupNamespaceSpecifiers: false,
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
+        importOrderSortByLength: null,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: "ImportDeclaration", value: './test' },

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

@@ -47,7 +47,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([
@@ -92,7 +93,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([
@@ -137,7 +139,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([
@@ -182,7 +185,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',
@@ -226,7 +230,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',
@@ -270,7 +275,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',
@@ -314,7 +320,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',
@@ -339,7 +346,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([
@@ -357,6 +365,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'],
@@ -368,6 +428,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

@@ -26,7 +26,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.js';
 export const getSortedNodesByImportOrder: GetSortedNodes = (nodes, options) => {
     naturalSort.insensitive = options.importOrderCaseInsensitive;
 
-    let { importOrder } = options;
+    let { importOrder,importOrderSortByLength } = options;
     const {
         importOrderSeparation,
         importOrderSortSpecifiers,
@@ -63,6 +63,7 @@ export const getSortedNodesByImportOrder: GetSortedNodes = (nodes, options) => {
 
         const sortedInsideGroup = getSortedNodesGroup(groupNodes, {
             importOrderGroupNamespaceSpecifiers,
+            importOrderSortByLength
         });
 
         // Sort the import specifiers