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

package/dist/index.js

@@ -0,0 +1,464 @@
+import { createRequire } from "module";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+function analyzeUsedIdentifiers(code) {
+    const usedIdentifiers = new Set();
+    try {
+        const ast = parse(code, {
+            sourceType: "module",
+            plugins: [
+                "typescript",
+                "jsx"
+            ],
+            errorRecovery: true
+        });
+        traverse(ast, {
+            Identifier (path) {
+                const node = path.node;
+                const parent = path.parent;
+                if (path.isBindingIdentifier()) return;
+                if (parent?.type === "ObjectProperty" && parent.key === node && !parent.computed) return;
+                usedIdentifiers.add(node.name);
+            },
+            JSXIdentifier (path) {
+                const node = path.node;
+                if (path.parent?.type === "JSXOpeningElement" || path.parent?.type === "JSXClosingElement") usedIdentifiers.add(node.name);
+            },
+            TSTypeReference (path) {
+                const node = path.node;
+                if ("Identifier" === node.typeName.type) usedIdentifiers.add(node.typeName.name);
+                else if ("TSQualifiedName" === node.typeName.type) {
+                    let current = node.typeName;
+                    while("TSQualifiedName" === current.type)current = current.left;
+                    if ("Identifier" === current.type) usedIdentifiers.add(current.name);
+                }
+            },
+            ExportNamedDeclaration (path) {
+                const node = path.node;
+                if (!node.source && node.specifiers) {
+                    for (const specifier of node.specifiers)if ("ExportSpecifier" === specifier.type) {
+                        if ("Identifier" === specifier.local.type) usedIdentifiers.add(specifier.local.name);
+                    }
+                }
+            }
+        });
+    } catch (error) {
+        console.error("Failed to analyze used identifiers:", error);
+    }
+    return usedIdentifiers;
+}
+function filterUnusedImports(importStatement, usedIdentifiers) {
+    if (importStatement.isSideEffect || importStatement.isExport) return importStatement;
+    const usedContents = [];
+    for (const content of importStatement.importContents){
+        const usedName = content.alias ?? content.name;
+        if ("default" === content.name || "*" === content.name) {
+            if (content.alias && usedIdentifiers.has(content.alias)) usedContents.push(content);
+        } else if (usedIdentifiers.has(usedName)) usedContents.push(content);
+    }
+    return {
+        ...importStatement,
+        importContents: usedContents,
+        isSideEffect: 0 === usedContents.length
+    };
+}
+function removeUnusedImportsFromStatements(importStatements, code) {
+    const usedIdentifiers = analyzeUsedIdentifiers(code);
+    const filteredStatements = [];
+    for (const statement of importStatements){
+        const filteredStatement = filterUnusedImports(statement, usedIdentifiers);
+        if (statement.isSideEffect || !filteredStatement.isSideEffect || 0 !== filteredStatement.importContents.length) filteredStatements.push(filteredStatement);
+    }
+    return filteredStatements;
+}
+function formatImportStatement(statement) {
+    const { path, isExport, isSideEffect, importContents, leadingComments } = 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}"`);
+        return lines.join("\n");
+    }
+    const parts = [];
+    const namedParts = [];
+    for (const content of importContents){
+        if ("default" === content.name) {
+            parts.push(content.alias ?? "default");
+            continue;
+        }
+        if ("*" === content.name) {
+            parts.push(`* as ${content.alias ?? "namespace"}`);
+            continue;
+        }
+        const typePrefix = "type" === content.type ? "type " : "";
+        if (content.alias) namedParts.push(`${typePrefix}${content.name} as ${content.alias}`);
+        else namedParts.push(`${typePrefix}${content.name}`);
+    }
+    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) {
+    const lines = [];
+    const separator = config.separator;
+    for(let i = 0; i < groups.length; i++){
+        const group = groups[i];
+        if (void 0 !== separator) {
+            let separatorStr;
+            separatorStr = "string" == typeof separator ? separator : separator(group, i);
+            if (void 0 !== separatorStr) {
+                lines.push("");
+                if ("" !== separatorStr) lines.push(separatorStr);
+            }
+        }
+        for (const statement of group.importStatements)lines.push(formatImportStatement(statement));
+    }
+    return lines.join("\n");
+}
+function formatImportStatements(statements) {
+    return statements.map(formatImportStatement).join("\n");
+}
+function parseImports(code) {
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: [
+            "typescript",
+            "jsx"
+        ],
+        errorRecovery: true
+    });
+    const importStatements = [];
+    const { body } = ast.program;
+    for (const node of body)if ("ImportDeclaration" === node.type || "ExportNamedDeclaration" === node.type && node.source || "ExportAllDeclaration" === node.type) {
+        const statement = parseImportNode(node, ast.comments ?? []);
+        importStatements.push(statement);
+    } else break;
+    return importStatements;
+}
+function parseImportNode(node, comments) {
+    node.type;
+    const source = node.source?.value ?? "";
+    const leadingComments = [];
+    let start = node.start ?? 0;
+    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}*/`);
+    }
+    const end = node.end ?? 0;
+    if ("ImportDeclaration" === node.type) {
+        const importContents = parseImportSpecifiers(node);
+        const isSideEffect = 0 === importContents.length;
+        return {
+            path: source,
+            isExport: false,
+            isSideEffect,
+            importContents,
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            start,
+            end
+        };
+    }
+    if ("ExportAllDeclaration" === node.type) return {
+        path: source,
+        isExport: true,
+        isSideEffect: false,
+        importContents: [],
+        leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+        start,
+        end
+    };
+    const importContents = parseExportSpecifiers(node);
+    return {
+        path: source,
+        isExport: true,
+        isSideEffect: false,
+        importContents,
+        leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+        start,
+        end
+    };
+}
+function parseImportSpecifiers(node) {
+    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"
+        });
+    }
+    return contents;
+}
+function parseExportSpecifiers(node) {
+    const contents = [];
+    if (!node.specifiers) return contents;
+    for (const specifier of node.specifiers)if ("ExportSpecifier" === specifier.type) {
+        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"
+        });
+    }
+    return contents;
+}
+function defaultGetGroup() {
+    return "default";
+}
+function defaultSortGroup(a, b) {
+    return a.name.localeCompare(b.name);
+}
+function getImportType(path) {
+    if (path.startsWith("./") || path.startsWith("../")) return "relative";
+    if (path.startsWith("@/") || path.startsWith("~/") || path.startsWith("#/")) return "alias";
+    if (path.startsWith("/")) return "alias";
+    return "module";
+}
+function getImportTypePriority(type) {
+    switch(type){
+        case "module":
+            return 0;
+        case "alias":
+            return 1;
+        case "relative":
+            return 2;
+    }
+}
+function defaultSortImportStatement(a, b) {
+    const aType = getImportType(a.path);
+    const bType = getImportType(b.path);
+    const aPriority = getImportTypePriority(aType);
+    const bPriority = getImportTypePriority(bType);
+    if (aPriority !== bPriority) return aPriority - bPriority;
+    return a.path.localeCompare(b.path);
+}
+function defaultSortImportContent(a, b) {
+    if ("type" === a.type && "type" !== b.type) return -1;
+    if ("type" !== a.type && "type" === b.type) return 1;
+    const aName = a.alias ?? a.name;
+    const bName = b.alias ?? b.name;
+    return aName.localeCompare(bName);
+}
+const DEFAULT_CONFIG = {
+    getGroup: defaultGetGroup,
+    sortGroup: defaultSortGroup,
+    sortImportStatement: defaultSortImportStatement,
+    sortImportContent: defaultSortImportContent,
+    sortSideEffect: false
+};
+function mergeConfig(userConfig) {
+    return {
+        getGroup: userConfig.getGroup ?? DEFAULT_CONFIG.getGroup,
+        sortGroup: userConfig.sortGroup ?? DEFAULT_CONFIG.sortGroup,
+        sortImportStatement: userConfig.sortImportStatement ?? DEFAULT_CONFIG.sortImportStatement,
+        sortImportContent: userConfig.sortImportContent ?? DEFAULT_CONFIG.sortImportContent,
+        separator: userConfig.separator,
+        sortSideEffect: userConfig.sortSideEffect ?? DEFAULT_CONFIG.sortSideEffect,
+        removeUnusedImports: userConfig.removeUnusedImports ?? false
+    };
+}
+function sortImports(imports, userConfig) {
+    const config = mergeConfig(userConfig);
+    if (!config.sortSideEffect) return sortImportsWithSideEffectSeparators(imports, config);
+    const groups = groupImports(imports, config);
+    const sortedGroups = sortGroups(groups, config);
+    const result = [];
+    for (const group of sortedGroups){
+        const sortedStatements = sortImportStatements(group.importStatements, config);
+        for (const statement of sortedStatements){
+            const sortedContents = sortImportContents(statement.importContents, config);
+            result.push({
+                ...statement,
+                importContents: sortedContents
+            });
+        }
+    }
+    return result;
+}
+function sortImportsWithSideEffectSeparators(imports, config) {
+    const result = [];
+    const chunks = [];
+    let currentChunk = [];
+    for (const statement of imports)if (statement.isSideEffect) {
+        if (currentChunk.length > 0) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+        }
+        chunks.push([
+            statement
+        ]);
+    } else currentChunk.push(statement);
+    if (currentChunk.length > 0) chunks.push(currentChunk);
+    for (const chunk of chunks){
+        if (1 === chunk.length && chunk[0].isSideEffect) {
+            result.push(chunk[0]);
+            continue;
+        }
+        const groups = groupImports(chunk, config);
+        const sortedGroups = sortGroups(groups, config);
+        for (const group of sortedGroups){
+            const sortedStatements = sortImportStatements(group.importStatements, config);
+            for (const statement of sortedStatements){
+                const sortedContents = sortImportContents(statement.importContents, config);
+                result.push({
+                    ...statement,
+                    importContents: sortedContents
+                });
+            }
+        }
+    }
+    return result;
+}
+function groupImports(imports, userConfig) {
+    const config = mergeConfig(userConfig);
+    const groupMap = new Map();
+    for (const statement of imports){
+        const groupName = config.getGroup(statement);
+        const statements = groupMap.get(groupName) ?? [];
+        statements.push(statement);
+        groupMap.set(groupName, statements);
+    }
+    const groups = [];
+    for (const [name, statements] of Array.from(groupMap.entries())){
+        const isSideEffect = statements.every((s)=>s.isSideEffect);
+        groups.push({
+            name,
+            isSideEffect,
+            importStatements: statements
+        });
+    }
+    return groups;
+}
+function sortGroups(groups, userConfig) {
+    const config = mergeConfig(userConfig);
+    return [
+        ...groups
+    ].sort(config.sortGroup);
+}
+function sortImportStatements(statements, userConfig) {
+    const config = mergeConfig(userConfig);
+    return [
+        ...statements
+    ].sort(config.sortImportStatement);
+}
+function sortImportContents(contents, userConfig) {
+    const config = mergeConfig(userConfig);
+    if (userConfig.sortImportContent) return [
+        ...contents
+    ].sort(config.sortImportContent);
+    const defaultImport = contents.filter((c)=>"default" === c.name);
+    const namespaceImport = contents.filter((c)=>"*" === c.name);
+    const namedImports = contents.filter((c)=>"default" !== c.name && "*" !== c.name);
+    return [
+        ...defaultImport,
+        ...namespaceImport,
+        ...namedImports.sort(config.sortImportContent)
+    ];
+}
+const src_require = createRequire(import.meta.url);
+let src_userConfig = {};
+function preprocessImports(text, options) {
+    try {
+        const imports = parseImports(text);
+        if (0 === imports.length) return text;
+        const config = {
+            getGroup: src_userConfig.getGroup ?? options.getGroup,
+            sortGroup: src_userConfig.sortGroup ?? options.sortGroup,
+            sortImportStatement: src_userConfig.sortImportStatement ?? options.sortImportStatement,
+            sortImportContent: src_userConfig.sortImportContent ?? options.sortImportContent,
+            separator: src_userConfig.separator ?? options.importSortSeparator ?? options.separator,
+            sortSideEffect: src_userConfig.sortSideEffect ?? options.importSortSideEffect ?? false,
+            removeUnusedImports: src_userConfig.removeUnusedImports ?? options.importSortRemoveUnused ?? false
+        };
+        let processedImports = imports;
+        if (config.removeUnusedImports) {
+            const lastImport = imports[imports.length - 1];
+            const codeAfterImports = text.slice(lastImport.end ?? 0);
+            processedImports = removeUnusedImportsFromStatements(imports, codeAfterImports);
+        }
+        const sortedImports = sortImports(processedImports, config);
+        let formattedImports;
+        if (config.getGroup) {
+            const groups = groupImports(sortedImports, config);
+            const sortedGroups = sortGroups(groups, config);
+            formattedImports = formatGroups(sortedGroups, config);
+        } else formattedImports = formatImportStatements(sortedImports);
+        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;
+    } catch (error) {
+        console.error("Failed to sort imports:", error);
+        return text;
+    }
+}
+const babelParser = src_require("prettier/parser-babel").parsers.babel;
+const typescriptParser = src_require("prettier/parser-typescript").parsers.typescript;
+const babelTsParser = src_require("prettier/parser-babel").parsers["babel-ts"];
+function createPluginInstance() {
+    return {
+        parsers: {
+            babel: {
+                ...babelParser,
+                preprocess: preprocessImports
+            },
+            typescript: {
+                ...typescriptParser,
+                preprocess: preprocessImports
+            },
+            "babel-ts": {
+                ...babelTsParser,
+                preprocess: preprocessImports
+            }
+        },
+        options: {
+            importSortSeparator: {
+                type: "string",
+                category: "Import Sort",
+                description: "分组之间的分隔符"
+            },
+            importSortSideEffect: {
+                type: "boolean",
+                category: "Import Sort",
+                description: "是否对副作用导入进行排序",
+                default: false
+            },
+            importSortRemoveUnused: {
+                type: "boolean",
+                category: "Import Sort",
+                description: "是否删除未使用的导入",
+                default: false
+            }
+        }
+    };
+}
+const src_plugin = createPluginInstance();
+function createPlugin(config = {}) {
+    src_userConfig = config;
+    return createPluginInstance();
+}
+const src = src_plugin;
+export { createPlugin, src as default };

package/dist/parser.d.ts

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

package/dist/sorter.d.ts

@@ -0,0 +1,16 @@
+import { Group, ImportContent, ImportStatement, PluginConfig } from "./types";
+/** 合并后的配置 */
+export interface MergedConfig extends Omit<Required<PluginConfig>, "separator" | "removeUnusedImports"> {
+    separator: PluginConfig["separator"];
+    removeUnusedImports: boolean;
+}
+/** 对导入语句进行排序 */
+export declare function sortImports(imports: ImportStatement[], userConfig: PluginConfig): ImportStatement[];
+/** 对导入语句进行分组 */
+export declare function groupImports(imports: ImportStatement[], userConfig: PluginConfig): Group[];
+/** 对分组进行排序 */
+export declare function sortGroups(groups: Group[], userConfig: PluginConfig): Group[];
+/** 对导入语句进行排序 */
+export declare function sortImportStatements(statements: ImportStatement[], userConfig: PluginConfig): ImportStatement[];
+/** 对导入内容进行排序 */
+export declare function sortImportContents(contents: ImportContent[], userConfig: PluginConfig): ImportContent[];

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/** 导入内容 */
+export interface ImportContent {
+    /** 导入的内容的名称 */
+    name: string;
+    /** 导入的内容的别名 */
+    alias?: string;
+    /** 导入的内容的类型，只有明确在导入前加入了 type 标记的才属于 type 类型，没有明确的加入 type 标记的都属于 variable 类型 */
+    type: "type" | "variable";
+}
+/** 导入语句 */
+export interface ImportStatement {
+    /** 导入的模块路径，可以是相对路径或绝对路径，比如 react, react-dom 或者 ./utils/index，@/utils/index 等 */
+    path: string;
+    /** 是否是导出语句，默认为 false */
+    isExport: boolean;
+    /** 是否是副作用导入，默认为 false */
+    isSideEffect: boolean;
+    /** 导入的内容 */
+    importContents: ImportContent[];
+    /** 导入语句上方的注释 */
+    leadingComments?: string[];
+    /** 在源代码中的起始位置（包括注释） */
+    start?: number;
+    /** 在源代码中的结束位置 */
+    end?: number;
+}
+/** 分组 */
+export interface Group {
+    /** 分组名称，默认为 default */
+    name: string;
+    /** 是否是副作用分组，默认为 false */
+    isSideEffect: boolean;
+    /** 分组对应的导入语句列表 */
+    importStatements: ImportStatement[];
+}
+/** 获取分组名称的函数 */
+export type GetGroupFunction = (importStatement: ImportStatement) => string;
+/** 分组排序函数 */
+export type SortGroupFunction = (a: Group, b: Group) => number;
+/** 导入语句排序函数 */
+export type SortImportStatementFunction = (a: ImportStatement, b: ImportStatement) => number;
+/** 导入内容排序函数 */
+export type SortImportContentFunction = (a: ImportContent, b: ImportContent) => number;
+/** 分隔符函数 */
+export type SeparatorFunction = (group: Group, index: number) => string | undefined;
+/** 插件配置 */
+export interface PluginConfig {
+    /** 可选的，获取分组名称 */
+    getGroup?: GetGroupFunction;
+    /** 可选的，默认按照分组名称的字母顺序排序 */
+    sortGroup?: SortGroupFunction;
+    /** 可选的，默认按照导入语句的 path 的字母顺序排序 */
+    sortImportStatement?: SortImportStatementFunction;
+    /** 可选的，默认按照导入内容的 name 的字母顺序排序，默认按照优先 type 类型在前，其次按照最终导入的内容名称的字母顺序排序 */
+    sortImportContent?: SortImportContentFunction;
+    /** 分隔符，分组之间的分隔符，默认为 undefined */
+    separator?: string | SeparatorFunction;
+    /** 是否对副作用导入进行排序，默认为 false */
+    sortSideEffect?: boolean;
+    /** 是否删除未使用的导入，默认为 false */
+    removeUnusedImports?: boolean;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+    "name": "@1adybug/prettier-plugin-sort-imports",
+    "type": "module",
+    "version": "0.0.1",
+    "description": "一个 Prettier 插件，用于对 JavaScript/TypeScript 文件的导入语句进行分组和排序",
+    "keywords": [
+        "prettier",
+        "plugin",
+        "import",
+        "sort",
+        "organize",
+        "typescript",
+        "javascript"
+    ],
+    "author": "1adybug <lurongv@qq.com>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/1adybug/prettier-plugin-sort-imports.git"
+    },
+    "homepage": "https://github.com/1adybug/prettier-plugin-sort-imports#readme",
+    "bugs": {
+        "url": "https://github.com/1adybug/prettier-plugin-sort-imports/issues"
+    },
+    "sideEffects": false,
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.com/"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "rslib build",
+        "dev": "rslib build --watch",
+        "prepublishOnly": "npm run build",
+        "format": "prettier --config prettier.config.mjs --write ."
+    },
+    "devDependencies": {
+        "@rslib/core": "^0.15.0",
+        "@types/babel__core": "^7.20.5",
+        "@types/node": "^22.18.6",
+        "prettier": "^3.6.2",
+        "supports-color": "^10.2.2",
+        "typescript": "^5.9.2"
+    },
+    "peerDependencies": {
+        "prettier": "^3.0.0"
+    },
+    "dependencies": {
+        "@babel/core": "^7.28.4",
+        "@babel/parser": "^7.28.4",
+        "@babel/types": "^7.28.4"
+    }
+}