@1adybug/prettier-plugin-sort-imports 0.0.1 → 0.0.2

package/dist/analyzer.d.ts

@@ -1,5 +1,4 @@
-import { ImportStatement } from "./types";
-/** 分析代码中使用的标识符 */
+import { ImportStatement } from "./types"; /** 分析代码中使用的标识符 */
 export declare function analyzeUsedIdentifiers(code: string): Set<string>;
 /** 过滤未使用的导入内容 */
 export declare function filterUnusedImports(importStatement: ImportStatement, usedIdentifiers: Set<string>): ImportStatement;

package/dist/formatter.d.ts

@@ -1,5 +1,4 @@
-import { Group, ImportStatement, PluginConfig } from "./types";
-/** 格式化导入语句 */
+import { Group, ImportStatement, PluginConfig } from "./types"; /** 格式化导入语句 */
 export declare function formatImportStatement(statement: ImportStatement): string;
 /** 格式化分组 */
 export declare function formatGroups(groups: Group[], config: PluginConfig): string;

package/dist/index.js

@@ -72,16 +72,20 @@ function removeUnusedImportsFromStatements(importStatements, code) {
     return filteredStatements;
 }
 function formatImportStatement(statement) {
-    const { path, isExport, isSideEffect, importContents, leadingComments } = statement;
+    const { path, isExport, isSideEffect, importContents, leadingComments, trailingComments, removedTrailingComments } = statement;
     const lines = [];
     if (leadingComments && leadingComments.length > 0) lines.push(...leadingComments);
     if (isSideEffect) {
-        if (isExport) lines.push(`export * from "${path}"`);
-        else lines.push(`import "${path}"`);
+        let importLine = "";
+        importLine = isExport ? `export * from "${path}"` : `import "${path}"`;
+        if (trailingComments && trailingComments.length > 0) importLine += ` ${trailingComments.join(" ")}`;
+        lines.push(importLine);
         return lines.join("\n");
     }
+    const hasNamedImportComments = importContents.some((content)=>"default" !== content.name && "*" !== content.name && (content.leadingComments && content.leadingComments.length > 0 || content.trailingComments && content.trailingComments.length > 0));
     const parts = [];
     const namedParts = [];
+    const namedPartsWithComments = [];
     for (const content of importContents){
         if ("default" === content.name) {
             parts.push(content.alias ?? "default");
@@ -92,13 +96,45 @@ function formatImportStatement(statement) {
             continue;
         }
         const typePrefix = "type" === content.type ? "type " : "";
-        if (content.alias) namedParts.push(`${typePrefix}${content.name} as ${content.alias}`);
-        else namedParts.push(`${typePrefix}${content.name}`);
+        let importItem = "";
+        importItem = content.alias ? `${typePrefix}${content.name} as ${content.alias}` : `${typePrefix}${content.name}`;
+        if (hasNamedImportComments) {
+            const itemLines = [];
+            if (content.leadingComments && content.leadingComments.length > 0) itemLines.push(...content.leadingComments);
+            let itemLine = importItem;
+            if (content.trailingComments && content.trailingComments.length > 0) itemLine += ` ${content.trailingComments.join(" ")}`;
+            itemLines.push(itemLine);
+            namedPartsWithComments.push(itemLines.join("\n    "));
+        } else namedParts.push(importItem);
+    }
+    const namedImports = importContents.filter((c)=>"default" !== c.name && "*" !== c.name);
+    const allNamedImportsAreTypes = namedImports.every((c)=>"type" === c.type);
+    const hasDefaultOrNamespace = importContents.some((c)=>"default" === c.name || "*" === c.name);
+    if (hasNamedImportComments && namedPartsWithComments.length > 0) {
+        const keyword = isExport ? "export" : "import";
+        const typeKeyword = allNamedImportsAreTypes && !hasDefaultOrNamespace ? "type " : "";
+        const defaultPart = parts.length > 0 ? parts.join(", ") + ", " : "";
+        const importStart = `${keyword} ${typeKeyword}${defaultPart}{`;
+        const importEnd = `} from "${path}"`;
+        lines.push(importStart);
+        lines.push(`    ${namedPartsWithComments.join(",\n    ")},`);
+        lines.push(importEnd);
+    } else {
+        if (namedParts.length > 0) if (allNamedImportsAreTypes && !hasDefaultOrNamespace) {
+            const cleanedParts = namedParts.map((part)=>part.replace(/^type /, ""));
+            parts.push(`{ ${cleanedParts.join(", ")} }`);
+        } else parts.push(`{ ${namedParts.join(", ")} }`);
+        const importClause = parts.join(", ");
+        const typeKeyword = allNamedImportsAreTypes && !hasDefaultOrNamespace ? "type " : "";
+        let importLine = "";
+        importLine = isExport ? `export ${typeKeyword}${importClause} from "${path}"` : `import ${typeKeyword}${importClause} from "${path}"`;
+        if (trailingComments && trailingComments.length > 0) importLine += ` ${trailingComments.join(" ")}`;
+        lines.push(importLine);
+    }
+    if (removedTrailingComments && removedTrailingComments.length > 0) {
+        lines.push("");
+        lines.push(...removedTrailingComments);
     }
-    if (namedParts.length > 0) parts.push(`{ ${namedParts.join(", ")} }`);
-    const importClause = parts.join(", ");
-    if (isExport) lines.push(`export ${importClause} from "${path}"`);
-    else lines.push(`import ${importClause} from "${path}"`);
     return lines.join("\n");
 }
 function formatGroups(groups, config) {
@@ -128,30 +164,55 @@ function parseImports(code) {
             "typescript",
             "jsx"
         ],
-        errorRecovery: true
+        errorRecovery: true,
+        attachComment: true
     });
     const importStatements = [];
     const { body } = ast.program;
+    const usedComments = new Set();
     for (const node of body)if ("ImportDeclaration" === node.type || "ExportNamedDeclaration" === node.type && node.source || "ExportAllDeclaration" === node.type) {
-        const statement = parseImportNode(node, ast.comments ?? []);
+        const statement = parseImportNode(node, ast.comments ?? [], usedComments);
         importStatements.push(statement);
     } else break;
     return importStatements;
 }
-function parseImportNode(node, comments) {
+function parseImportNode(node, comments, usedComments) {
     node.type;
     const source = node.source?.value ?? "";
+    node.loc?.start.line;
+    node.loc?.end.line;
+    const nodeStart = node.start ?? 0;
+    let nodeEnd = node.end ?? 0;
     const leadingComments = [];
-    let start = node.start ?? 0;
+    const trailingComments = [];
+    let start = nodeStart;
     if (node.leadingComments) {
-        const firstComment = node.leadingComments[0];
-        if (null !== firstComment.start && void 0 !== firstComment.start) start = firstComment.start;
-        for (const comment of node.leadingComments)if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
-        else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+        for (const comment of node.leadingComments)if (!usedComments.has(comment)) {
+            if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+            const commentStart = comment.start ?? 0;
+            if (commentStart < start) start = commentStart;
+            usedComments.add(comment);
+        }
+    }
+    if (node.trailingComments) {
+        for (const comment of node.trailingComments)if (!usedComments.has(comment)) {
+            const commentLoc = comment.loc;
+            const nodeLoc = node.loc;
+            const isSameLine = commentLoc && nodeLoc && commentLoc.start.line === nodeLoc.end.line;
+            if (isSameLine) {
+                if ("CommentLine" === comment.type) trailingComments.push(`//${comment.value}`);
+                else if ("CommentBlock" === comment.type) trailingComments.push(`/*${comment.value}*/`);
+                const commentEnd = comment.end ?? 0;
+                if (commentEnd > nodeEnd) nodeEnd = commentEnd;
+                usedComments.add(comment);
+            }
+        }
     }
-    const end = node.end ?? 0;
+    const end = nodeEnd;
     if ("ImportDeclaration" === node.type) {
-        const importContents = parseImportSpecifiers(node);
+        const isTypeOnlyImport = "type" === node.importKind;
+        const importContents = parseImportSpecifiers(node, isTypeOnlyImport);
         const isSideEffect = 0 === importContents.length;
         return {
             path: source,
@@ -159,6 +220,7 @@ function parseImportNode(node, comments) {
             isSideEffect,
             importContents,
             leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0,
             start,
             end
         };
@@ -169,6 +231,7 @@ function parseImportNode(node, comments) {
         isSideEffect: false,
         importContents: [],
         leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+        trailingComments: trailingComments.length > 0 ? trailingComments : void 0,
         start,
         end
     };
@@ -179,31 +242,50 @@ function parseImportNode(node, comments) {
         isSideEffect: false,
         importContents,
         leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+        trailingComments: trailingComments.length > 0 ? trailingComments : void 0,
         start,
         end
     };
 }
-function parseImportSpecifiers(node) {
+function parseImportSpecifiers(node, isTypeOnlyImport = false) {
     const contents = [];
-    for (const specifier of node.specifiers)if ("ImportDefaultSpecifier" === specifier.type) contents.push({
-        name: "default",
-        alias: specifier.local.name,
-        type: "variable"
-    });
-    else if ("ImportNamespaceSpecifier" === specifier.type) contents.push({
-        name: "*",
-        alias: specifier.local.name,
-        type: "variable"
-    });
-    else if ("ImportSpecifier" === specifier.type) {
-        const importedName = "Identifier" === specifier.imported.type ? specifier.imported.name : specifier.imported.value;
-        const localName = specifier.local.name;
-        const isTypeImport = "type" === specifier.importKind;
-        contents.push({
-            name: importedName,
-            alias: importedName !== localName ? localName : void 0,
-            type: isTypeImport ? "type" : "variable"
+    for (const specifier of node.specifiers){
+        const leadingComments = [];
+        const trailingComments = [];
+        if (specifier.leadingComments) {
+            for (const comment of specifier.leadingComments)if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+        }
+        if (specifier.trailingComments) {
+            for (const comment of specifier.trailingComments)if ("CommentLine" === comment.type) trailingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) trailingComments.push(`/*${comment.value}*/`);
+        }
+        if ("ImportDefaultSpecifier" === specifier.type) contents.push({
+            name: "default",
+            alias: specifier.local.name,
+            type: isTypeOnlyImport ? "type" : "variable",
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0
         });
+        else if ("ImportNamespaceSpecifier" === specifier.type) contents.push({
+            name: "*",
+            alias: specifier.local.name,
+            type: isTypeOnlyImport ? "type" : "variable",
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0
+        });
+        else if ("ImportSpecifier" === specifier.type) {
+            const importedName = "Identifier" === specifier.imported.type ? specifier.imported.name : specifier.imported.value;
+            const localName = specifier.local.name;
+            const isTypeImport = isTypeOnlyImport || "type" === specifier.importKind;
+            contents.push({
+                name: importedName,
+                alias: importedName !== localName ? localName : void 0,
+                type: isTypeImport ? "type" : "variable",
+                leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+                trailingComments: trailingComments.length > 0 ? trailingComments : void 0
+            });
+        }
     }
     return contents;
 }
@@ -211,13 +293,25 @@ function parseExportSpecifiers(node) {
     const contents = [];
     if (!node.specifiers) return contents;
     for (const specifier of node.specifiers)if ("ExportSpecifier" === specifier.type) {
+        const leadingComments = [];
+        const trailingComments = [];
+        if (specifier.leadingComments) {
+            for (const comment of specifier.leadingComments)if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+        }
+        if (specifier.trailingComments) {
+            for (const comment of specifier.trailingComments)if ("CommentLine" === comment.type) trailingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) trailingComments.push(`/*${comment.value}*/`);
+        }
         const localName = "Identifier" === specifier.local.type ? specifier.local.name : specifier.local.value;
         const exportedName = "Identifier" === specifier.exported.type ? specifier.exported.name : specifier.exported.value;
         const isTypeExport = "type" === specifier.exportKind;
         contents.push({
             name: localName,
             alias: localName !== exportedName ? exportedName : void 0,
-            type: isTypeExport ? "type" : "variable"
+            type: isTypeExport ? "type" : "variable",
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0
         });
     }
     return contents;
@@ -375,6 +469,61 @@ function sortImportContents(contents, userConfig) {
         ...namedImports.sort(config.sortImportContent)
     ];
 }
+function mergeImports(imports) {
+    const mergedMap = new Map();
+    for (const statement of imports){
+        if (statement.isSideEffect) {
+            const key = `${statement.path}|||${statement.isExport}|||sideEffect|||${statement.start}`;
+            mergedMap.set(key, statement);
+            continue;
+        }
+        const hasNamespaceImport = statement.importContents.some((c)=>"*" === c.name);
+        if (hasNamespaceImport) {
+            const key = `${statement.path}|||${statement.isExport}|||namespace|||${statement.start}`;
+            mergedMap.set(key, statement);
+            continue;
+        }
+        const key = `${statement.path}|||${statement.isExport}`;
+        const existing = mergedMap.get(key);
+        if (existing) {
+            const mergedContents = [
+                ...existing.importContents
+            ];
+            for (const content of statement.importContents){
+                const existingContent = mergedContents.find((c)=>c.name === content.name && c.alias === content.alias);
+                if (existingContent) {
+                    if (content.leadingComments) existingContent.leadingComments = [
+                        ...existingContent.leadingComments ?? [],
+                        ...content.leadingComments
+                    ];
+                    if (content.trailingComments) existingContent.trailingComments = [
+                        ...existingContent.trailingComments ?? [],
+                        ...content.trailingComments
+                    ];
+                } else mergedContents.push(content);
+            }
+            const mergedLeadingComments = [
+                ...existing.leadingComments ?? [],
+                ...statement.leadingComments ?? []
+            ];
+            const mergedTrailingComments = existing.trailingComments ?? [];
+            const removedTrailingComments = [
+                ...existing.removedTrailingComments ?? [],
+                ...statement.trailingComments ?? []
+            ];
+            mergedMap.set(key, {
+                ...existing,
+                importContents: mergedContents,
+                leadingComments: mergedLeadingComments.length > 0 ? mergedLeadingComments : void 0,
+                trailingComments: mergedTrailingComments.length > 0 ? mergedTrailingComments : void 0,
+                removedTrailingComments: removedTrailingComments.length > 0 ? removedTrailingComments : void 0
+            });
+        } else mergedMap.set(key, {
+            ...statement
+        });
+    }
+    return Array.from(mergedMap.values());
+}
 const src_require = createRequire(import.meta.url);
 let src_userConfig = {};
 function preprocessImports(text, options) {
@@ -397,19 +546,22 @@ function preprocessImports(text, options) {
             processedImports = removeUnusedImportsFromStatements(imports, codeAfterImports);
         }
         const sortedImports = sortImports(processedImports, config);
+        const mergedImports = mergeImports(sortedImports);
         let formattedImports;
         if (config.getGroup) {
-            const groups = groupImports(sortedImports, config);
+            const groups = groupImports(mergedImports, config);
             const sortedGroups = sortGroups(groups, config);
             formattedImports = formatGroups(sortedGroups, config);
-        } else formattedImports = formatImportStatements(sortedImports);
+        } else formattedImports = formatImportStatements(mergedImports);
         const firstImport = imports[0];
         const lastImport = imports[imports.length - 1];
         const startIndex = firstImport.start ?? 0;
         const endIndex = lastImport.end ?? text.length;
         const beforeImports = text.slice(0, startIndex);
         const afterImports = text.slice(endIndex);
-        return beforeImports + formattedImports + "\n" + afterImports;
+        const needsExtraNewline = afterImports && !afterImports.startsWith("\n");
+        const separator = needsExtraNewline ? "\n\n" : "\n";
+        return beforeImports + formattedImports + separator + afterImports;
     } catch (error) {
         console.error("Failed to sort imports:", error);
         return text;

package/dist/parser.d.ts

@@ -1,3 +1,2 @@
-import { ImportStatement } from "./types";
-/** 解析导入语句 */
+import { ImportStatement } from "./types"; /** 解析导入语句 */
 export declare function parseImports(code: string): ImportStatement[];

package/dist/sorter.d.ts

@@ -1,4 +1,4 @@
-import { Group, ImportContent, ImportStatement, PluginConfig } from "./types";
+import { Group, ImportContent, ImportStatement, PluginConfig } from "./types"; /** 导入类型 */
 /** 合并后的配置 */
 export interface MergedConfig extends Omit<Required<PluginConfig>, "separator" | "removeUnusedImports"> {
     separator: PluginConfig["separator"];
@@ -14,3 +14,5 @@ export declare function sortGroups(groups: Group[], userConfig: PluginConfig): G
 export declare function sortImportStatements(statements: ImportStatement[], userConfig: PluginConfig): ImportStatement[];
 /** 对导入内容进行排序 */
 export declare function sortImportContents(contents: ImportContent[], userConfig: PluginConfig): ImportContent[];
+/** 合并来自同一模块的导入语句 */
+export declare function mergeImports(imports: ImportStatement[]): ImportStatement[];

package/dist/types.d.ts

@@ -6,6 +6,10 @@ export interface ImportContent {
     alias?: string;
     /** 导入的内容的类型，只有明确在导入前加入了 type 标记的才属于 type 类型，没有明确的加入 type 标记的都属于 variable 类型 */
     type: "type" | "variable";
+    /** 导入内容上方的注释 */
+    leadingComments?: string[];
+    /** 导入内容后方的行尾注释 */
+    trailingComments?: string[];
 }
 /** 导入语句 */
 export interface ImportStatement {
@@ -19,6 +23,10 @@ export interface ImportStatement {
     importContents: ImportContent[];
     /** 导入语句上方的注释 */
     leadingComments?: string[];
+    /** 导入语句后方的行尾注释 */
+    trailingComments?: string[];
+    /** 被移除的导入语句的行尾注释（合并时使用） */
+    removedTrailingComments?: string[];
     /** 在源代码中的起始位置（包括注释） */
     start?: number;
     /** 在源代码中的结束位置 */

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@1adybug/prettier-plugin-sort-imports",
     "type": "module",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "description": "一个 Prettier 插件，用于对 JavaScript/TypeScript 文件的导入语句进行分组和排序",
     "keywords": [
         "prettier",
@@ -41,11 +41,14 @@
         "build": "rslib build",
         "dev": "rslib build --watch",
         "prepublishOnly": "npm run build",
-        "format": "prettier --config prettier.config.mjs --write ."
+        "format": "prettier --config prettier.config.mjs --write .",
+        "test": "bun test",
+        "test:watch": "bun test --watch"
     },
     "devDependencies": {
         "@rslib/core": "^0.15.0",
         "@types/babel__core": "^7.20.5",
+        "@types/bun": "latest",
         "@types/node": "^22.18.6",
         "prettier": "^3.6.2",
         "supports-color": "^10.2.2",