feat: Add new config option for deduplicating import declarations

README.md

@@ -160,6 +160,30 @@ A boolean value to enable or disable sorting of the specifiers in an import decl
 
 A boolean value to enable or disable sorting the namespace specifiers to the top of the import group.
 
+#### `importOrderMergeImports`
+
+**type**: `boolean`
+
+**default value:** `false`
+
+Merges multiple import declarations into a single import declaration, combining all their specifiers.
+
+Initial file:
+```js
+import * as NamespacedImport from './example';
+import DefaultImport from './example';
+import { NamedImport1 } from './example';
+import { NamedImport2 } from './example';
+import { NamedImport3 } from './example';
+``` 
+
+When sorted
+```js
+// namespaced imports are ignored as they cannot contain other specifier types
+import * as NamespacedImport from './example'; 
+import DefaultImport, { NamedImport1, NamedImport2, NamedImport3 } from './example';
+```
+
 #### `importOrderCaseInsensitive`
 
 **type**: `boolean`

src/index.ts

@@ -93,6 +93,13 @@ const options: Options = {
         default: 'with',
         description: 'Provide a keyword for import attributes',
     },
+    importOrderMergeImports: {
+        type: 'boolean',
+        category: 'Global',
+        default: false,
+        description:
+            'Should duplicate import sources be combined into a single import declaration?',
+    },
 };
 
 export default {

src/preprocessors/preprocessor.ts

@@ -22,6 +22,7 @@ export function preprocessor(code: string, options: PrettierOptions) {
         importOrderSideEffects,
         importOrderImportAttributesKeyword,
         importOrderExclude,
+        importOrderMergeImports,
         filepath,
     } = options;
 
@@ -54,17 +55,18 @@ export function preprocessor(code: string, options: PrettierOptions) {
     if (importNodes.length === 0) return code;
     if (isSortImportsIgnored(getAllCommentsFromNodes(importNodes))) return code;
 
-    const allImports = getSortedNodes(importNodes, {
+    const sortedImports = getSortedNodes(importNodes, {
         importOrder,
         importOrderCaseInsensitive,
         importOrderSeparation,
         importOrderGroupNamespaceSpecifiers,
         importOrderSortSpecifiers,
         importOrderSortByLength,
         importOrderSideEffects,
+        importOrderMergeImports,
     });
 
-    return getCodeFromAst(allImports, code, injectIdx, {
+    return getCodeFromAst(importNodes, code, sortedImports, injectIdx, {
         importOrderImportAttributesKeyword,
     });
 }

src/types.ts

@@ -4,8 +4,7 @@ import { RequiredOptions } from 'prettier';
 import { PluginConfig } from '../types';
 
 export interface PrettierOptions
-    extends Required<PluginConfig>,
-        RequiredOptions {}
+    extends Required<PluginConfig>, RequiredOptions {}
 
 export type ImportGroups = Record<string, ImportDeclaration[]>;
 export type ImportOrLine = ImportDeclaration | ExpressionStatement;
@@ -21,6 +20,7 @@ export type GetSortedNodes = (
         | 'importOrderSortSpecifiers'
         | 'importOrderSortByLength'
         | 'importOrderSideEffects'
+        | 'importOrderMergeImports'
     >,
 ) => ImportOrLine[];
 

src/utils/__tests__/assemble-updated-code.spec.ts

@@ -29,6 +29,7 @@ test('it should remove nodes from the original code', async () => {
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     const allCommentsFromImports = getAllCommentsFromNodes(sortedNodes);
 
@@ -57,6 +58,7 @@ test('it should inject the generated code at the correct location', async () =>
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     const allCommentsFromImports = getAllCommentsFromNodes(sortedNodes);
 

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

@@ -17,6 +17,7 @@ const getSortedImportNodes = (code: string, options?: ParserOptions) => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     });
 };
 

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

@@ -24,8 +24,9 @@ import a from 'a';
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     });
-    const formatted = getCodeFromAst(sortedNodes, code);
+    const formatted = getCodeFromAst(importNodes, code, sortedNodes);
     expect(await format(formatted, { parser: 'babel' })).toEqual(
         `// first comment
 // second comment

src/utils/__tests__/get-merged-specifiers.spec.ts

@@ -0,0 +1,60 @@
+import { expect, test } from 'vitest';
+
+import { getImportNodes } from '../get-import-nodes';
+import { getMergedSpecifiers } from '../get-merged-specifiers.js';
+import { getSortedNodesModulesNames } from '../get-sorted-nodes-modules-names';
+
+test('should merge import specifiers', () => {
+    const code = `
+    import { eventHandler } from '@server/z';
+    import { filter } from '@server/z';
+    import { reduce } from '@server/z';
+    `;
+    const importNodes = getImportNodes(code);
+    const [importDeclaration] = getMergedSpecifiers(importNodes);
+    const specifiersList = getSortedNodesModulesNames(
+        importDeclaration.specifiers,
+    );
+
+    expect(specifiersList).toEqual(['eventHandler', 'filter', 'reduce']);
+});
+
+test('should merge import specifiers with default import', () => {
+    const code = `
+    import Component from '@server/z';
+    import { eventHandler } from '@server/z';
+    import { filter } from '@server/z';
+    import { reduce } from '@server/z';
+    `;
+    const importNodes = getImportNodes(code);
+    const [importDeclaration] = getMergedSpecifiers(importNodes);
+    const specifiersList = getSortedNodesModulesNames(
+        importDeclaration.specifiers,
+    );
+
+    expect(specifiersList).toEqual([
+        'Component',
+        'eventHandler',
+        'filter',
+        'reduce',
+    ]);
+});
+
+test('should ignore namespace specifiers', () => {
+    const code = `
+    import * as Component from '@server/z';
+    import { eventHandler } from '@server/z';
+    import { filter } from '@server/z';
+    import { reduce } from '@server/z';
+    `;
+    const importNodes = getImportNodes(code);
+    const importDeclarations = getMergedSpecifiers(importNodes);
+    const specifiersLists = importDeclarations.map((declaration) =>
+        getSortedNodesModulesNames(declaration.specifiers),
+    );
+
+    expect(specifiersLists).toEqual([
+        ['Component'],
+        ['eventHandler', 'filter', 'reduce'],
+    ]);
+});

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

@@ -33,6 +33,7 @@ test('it returns all sorted nodes', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -79,6 +80,7 @@ test('it returns all sorted nodes case-insensitive', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -125,6 +127,7 @@ test('it returns all sorted nodes with sort order', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -171,6 +174,7 @@ test('it returns all sorted nodes with sort order case-insensitive', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'c',
@@ -216,6 +220,7 @@ test('it returns all sorted import nodes with sorted import specifiers', () => {
         importOrderSortSpecifiers: true,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'XY',
@@ -261,6 +266,7 @@ test('it returns all sorted import nodes with sorted import specifiers with case
         importOrderSortSpecifiers: true,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'c',
@@ -306,6 +312,7 @@ test('it returns all sorted nodes with custom third party modules', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'a',
@@ -332,6 +339,7 @@ test('it returns all sorted nodes with namespace specifiers at the top', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -367,6 +375,7 @@ test('it returns the default separations if `importOrderSeparation` is false', (
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: 'ImportDeclaration', value: 'XY' },
@@ -394,6 +403,7 @@ test('it returns default import module separations', () => {
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: 'ImportDeclaration', value: 'XY' },
@@ -426,6 +436,7 @@ test('it returns targeted import module separations', () => {
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: 'ImportDeclaration', value: 'XY' },
@@ -459,6 +470,7 @@ test('it never returns a separation at the top of the list (leading separator)',
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: 'ImportDeclaration', value: './test' },
@@ -480,6 +492,7 @@ test('it never returns a separation at the top of the list (zero preceding impor
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     });
     expect(getSeparationData(sorted)).toEqual([
         { type: 'ImportDeclaration', value: './test' },

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

@@ -49,6 +49,7 @@ test('it returns all sorted nodes', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -95,6 +96,7 @@ test('it returns all sorted nodes case-insensitive', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -141,6 +143,7 @@ test('it returns all sorted nodes with sort order', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -187,6 +190,7 @@ test('it returns all sorted nodes with sort order case-insensitive', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'c',
@@ -232,6 +236,7 @@ test('it returns all sorted import nodes with sorted import specifiers', () => {
         importOrderSortSpecifiers: true,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'XY',
@@ -277,6 +282,7 @@ test('it returns all sorted import nodes with sorted import specifiers with case
         importOrderSortSpecifiers: true,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'c',
@@ -322,6 +328,7 @@ test('it returns all sorted nodes with custom third party modules', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'a',
@@ -348,6 +355,7 @@ test('it returns all sorted nodes with namespace specifiers at the top', () => {
         importOrderSortSpecifiers: false,
         importOrderSortByLength: null,
         importOrderSideEffects: true,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([
@@ -375,6 +383,7 @@ test('it returns all sorted nodes, sorted shortest to longest', () => {
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: 'asc',
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         'g',
@@ -401,6 +410,7 @@ test('it returns all sorted nodes, sorted longest to shortest', () => {
         importOrderSortSpecifiers: false,
         importOrderSideEffects: false,
         importOrderSortByLength: 'desc',
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
     expect(getSortedNodesNames(sorted)).toEqual([
         't',
@@ -429,6 +439,7 @@ test('it returns all sorted nodes with types', () => {
         importOrderSortSpecifiers: false,
         importOrderSideEffects: true,
         importOrderSortByLength: null,
+        importOrderMergeImports: false,
     }) as ImportDeclaration[];
 
     expect(getSortedNodesNames(sorted)).toEqual([