prettier-plugin-sort 0.1.0 → 0.2.0

package/README.md

@@ -56,7 +56,7 @@ import react from 'react';
 import App from './App.tsx';
 ```
 
-Each import belongs to a group. For example, `node:fs` is a `builtin` (covers Node.js / Bun / Deno built-ins), while `react` and `lodash` are `external` npm packages. The plugin first classifies each import by group, then sorts alphabetically within each group.
+Each import belongs to a group. For example, `node:fs` is a `builtin` (covers Node.js and Bun **runtime** built-ins), while `react` and `lodash` are `external` npm packages. The plugin first classifies each import by group, then sorts alphabetically within each group.
 
 Grouping and ordering follow the conventions of [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import)'s [import/order](https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/order.md) rule.
 
@@ -76,7 +76,7 @@ Group matchers:
 
 | Group      | Matches                                                     | Examples                           |
 | ---------- | ----------------------------------------------------------- | ---------------------------------- |
-| `builtin`  | `node:*`, `bun:*`, `deno:*`, and unprefixed Node built-ins  | `node:fs`, `path`                  |
+| `builtin`  | `node:*`, `bun:*`, `bun`, and unprefixed Node built-ins     | `node:fs`, `path`, `bun`           |
 | `external` | npm packages, and anything that doesn't match another group | `react`, `@scope/pkg`              |
 | `internal` | Project absolute paths and aliases                          | `/utils`, `~/app`, `@/shared`      |
 | `parent`   | Parent-relative paths                                       | `../Button`                        |
@@ -283,9 +283,10 @@ Top-level key order follows the field list maintained by [sort-package-json](htt
 Rules the plugin follows:
 
 - Top-level keys are reordered to the canonical sequence (`name` → `version` → ... → `dependencies`)
-- Top-level string-only arrays are sorted alphabetically, e.g. `keywords`, `files`
+- `scripts` and `betterScripts` keys are sorted with pre/post lifecycle grouping and `:` namespace ordering
+- `exports` keys are sorted: path subkeys first, conditions alphabetically with `default` moved to the end; nested export maps are recursively sorted
 - `dependencies`, `devDependencies`, `peerDependencies` and other dependency maps are always sorted alphabetically, even if `packageJsonOrder` is set to `false`, because `npm install` rewrites them in alphabetical order every time
-- `scripts`, `exports`, `imports` and other nested objects are not sorted recursively, because their key order carries runtime semantics
+- String arrays are handled by field: `keywords`, `files`, `activationEvents` are deduplicated preserving original order; `bundledDependencies`, `bundleDependencies`, `extensionPack`, `extensionDependencies` are deduplicated then sorted; `workspaces` arrays are left untouched; all other string arrays are sorted alphabetically
 - Use `packageJsonOrderExcludeKeys` to opt specific top-level keys out of sorting entirely
 
 ## Options
@@ -300,7 +301,7 @@ Prettier plugin options are flat, so these options are prefixed with `importOrde
 | `importOrderTypeImports`      | How to place `type` imports: `separate`, `inline-first`, `inline-last`, `mixed`            | `"separate"`                                            |
 | `importOrderMergeDuplicates`  | Merge multiple `import` statements from the same source (except side-effect imports)       | `true`                                                  |
 | `exportOrder`                 | Sort named specifiers inside `export { … }` alphabetically                                 | `true`                                                  |
-| `packageJsonOrder`            | Sort top-level keys and string arrays in `package.json`                                    | `true`                                                  |
+| `packageJsonOrder`            | Sort top-level keys, scripts/exports subkeys, and string arrays in `package.json`            | `true`                                                  |
 | `packageJsonOrderExcludeKeys` | Top-level `package.json` keys to leave untouched                                           | `[]`                                                    |
 
 ## Example

package/README.zh.md

@@ -56,7 +56,7 @@ import react from 'react';
 import App from './App.tsx';
 ```
 
-import 的模块一般可以按其来源分为不同的类别，例如上面的示例代码，'node:fs' 就属于 builtin 分类，该分类涵盖 Node.js、Bun、Deno 等**运行时**的内置模块。而像 react 和 lodash 这种直接从 npm 下载的依赖模块，属于 external 分类。
+import 的模块一般可以按其来源分为不同的类别，例如上面的示例代码，'node:fs' 就属于 builtin 分类，该分类涵盖 Node.js 和 Bun **运行时**的内置模块。而像 react 和 lodash 这种直接从 npm 下载的依赖模块，属于 external 分类。
 
 插件会先根据不同的模块进行分类，然后在模块内部基于字母顺序进行排列。
 
@@ -76,14 +76,14 @@ import 的模块一般可以按其来源分为不同的类别，例如上面的
 
 各分组的匹配规则如下：
 
-| 分组       | 匹配内容                                                | 示例                               |
-| ---------- | ------------------------------------------------------- | ---------------------------------- |
-| `builtin`  | `node:*`、`bun:*`、`deno:*`，以及无前缀的 Node 内置模块 | `node:fs`、`path`                  |
-| `external` | npm 包，以及不属于其他分组的模块                        | `react`、`@scope/pkg`              |
-| `internal` | 项目绝对路径与别名                                      | `/utils`、`~/app`、`@/shared`      |
-| `parent`   | 向上跳级的相对路径                                      | `../Button`                        |
-| `sibling`  | 同级相对路径（不包含 index）                            | `./Icon`                           |
-| `index`    | 当前目录的 index 模块                                   | `.`、`./`、`./index`、`./index.ts` |
+| 分组       | 匹配内容                                             | 示例                               |
+| ---------- | ---------------------------------------------------- | ---------------------------------- |
+| `builtin`  | `node:*`、`bun:*`、`bun`，以及无前缀的 Node 内置模块 | `node:fs`、`path`、`bun`           |
+| `external` | npm 包，以及不属于其他分组的模块                     | `react`、`@scope/pkg`              |
+| `internal` | 项目绝对路径与别名                                   | `/utils`、`~/app`、`@/shared`      |
+| `parent`   | 向上跳级的相对路径                                   | `../Button`                        |
+| `sibling`  | 同级相对路径（不包含 index）                         | `./Icon`                           |
+| `index`    | 当前目录的 index 模块                                | `.`、`./`、`./index`、`./index.ts` |
 
 > **关于 `internal` 的检测方式：** 插件目前通过说明符的前缀硬编码（`/`、`~`、`@/`）来判断，不会读取 tsconfig `paths` 或任何构建工具的配置。后续版本可能会提供 `importOrderInternalPatterns` 选项，支持自定义正则匹配。
 
@@ -286,9 +286,10 @@ export { type FC, useEffect, useState } from 'react';
 排序规则：
 
 - 顶层字段按常用顺序排列（`name` → `version` → ... → `dependencies`）
-- 顶层的纯字符串数组按字母序排列，如 `keywords`、`files`
+- `scripts` 和 `betterScripts` 的键名按 pre/post 生命周期包围和 `:` 命名空间分组排序
+- `exports` 键按路径优先、条件字母序、`default` 置底排序，嵌套的 export 对象递归处理
 - `dependencies`、`devDependencies`、`peerDependencies` 等依赖表永远按字母序排列，即使 `packageJsonOrder` 设为 `false` 也不例外。因为 `npm install` 每次都会按照字母序写回
-- `scripts`、`exports`、`imports` 等嵌套对象不会递归排序，它们的键顺序有运行时语义
+- 字符串数组按字段分类处理：`keywords`、`files`、`activationEvents` 只去重不排序，保留原始语义顺序；`bundledDependencies`、`bundleDependencies`、`extensionPack`、`extensionDependencies` 去重后按字母序排列；`workspaces` 数组不排序；其余字符串数组按字母序排列
 - 想让某些顶层字段完全跳过排序，可以在 `packageJsonOrderExcludeKeys` 里列出
 
 ## 配置项
@@ -303,7 +304,7 @@ Prettier 的插件选项是扁平的，所以这些配置都以 `importOrder`、
 | `importOrderTypeImports`      | `type` import 的处理方式：`separate`、`inline-first`、`inline-last`、`mixed`   | `"separate"`                                            |
 | `importOrderMergeDuplicates`  | 是否合并同来源的多条 import 语句（副作用导入除外）                             | `true`                                                  |
 | `exportOrder`                 | 是否按字母序排列 `export { … }` 花括号内的命名导出                             | `true`                                                  |
-| `packageJsonOrder`            | 是否排序 package.json 的顶层字段和字符串数组                                   | `true`                                                  |
+| `packageJsonOrder`            | 是否排序 package.json 的顶层字段、scripts/exports 子键和字符串数组                          | `true`                                                  |
 | `packageJsonOrderExcludeKeys` | 不参与 package.json 排序的顶层字段                                             | `[]`                                                    |
 
 ## 示例

package/dist/index.d.ts

@@ -1,28 +1,5 @@
-// Generated by dts-bundle-generator v9.5.1
-
-import { Plugin, SupportOptions } from 'prettier';
-
-/** import 分组，参考 eslint-plugin-import 的 import/order 规则。 */
-export type ImportGroup = "builtin" | "external" | "internal" | "parent" | "sibling" | "index";
-/** `import type` 内联风格，参考 @typescript-eslint/consistent-type-imports 的 fixStyle 选项。 */
-export type TypeImportsStyle = "separate" | "inline-first" | "inline-last" | "mixed";
-/** 插件排序配置。 */
-export interface SortOptions {
-	importOrder?: boolean;
-	importOrderGroups?: ImportGroup[];
-	importOrderSeparation?: boolean;
-	importOrderTypeImports?: TypeImportsStyle;
-	importOrderMergeDuplicates?: boolean;
-	exportOrder?: boolean;
-	packageJsonOrder?: boolean;
-	packageJsonOrderExcludeKeys?: string[];
-}
-/** 向 Prettier 注册的选项。使用功能名词前缀命名，因为 Prettier API 不支持嵌套选项对象。 */
-export declare const options: SupportOptions;
+import { type Plugin } from 'prettier';
 declare const plugin: Plugin;
-
-export {
-	plugin as default,
-};
-
-export {};
+export default plugin;
+export { options } from './options';
+export type { ImportGroup, SortOptions, TypeImportsStyle } from './options';

package/dist/index.js

@@ -172,8 +172,9 @@ function stripTypePrefix(member) {
 // src/sort-imports.ts
 import { builtinModules } from "node:module";
 var NODE_BUILTINS = new Set(builtinModules);
+var INDEX_PATTERN = /^\.\/index(\.[a-z]+)?$/;
 function detectGroup(source) {
-  if (source.startsWith("node:") || source.startsWith("bun:") || source.startsWith("deno:")) {
+  if (source === "bun" || source.startsWith("bun:") || source.startsWith("node:")) {
     return "builtin";
   }
   const slashIndex = source.indexOf("/");
@@ -181,7 +182,7 @@ function detectGroup(source) {
   if (head && NODE_BUILTINS.has(head)) {
     return "builtin";
   }
-  if (source === "." || source === "./" || /^\.\/index(\.[a-z]+)?$/.test(source)) {
+  if (source === "." || source === "./" || INDEX_PATTERN.test(source)) {
     return "index";
   }
   if (source.startsWith("../") || source === "..") {
@@ -195,7 +196,7 @@ function detectGroup(source) {
   }
   return "external";
 }
-var TYPE_PREFIX = /^type\s+(.+)$/s;
+var TYPE_PREFIX = /^type\s+(.+)$/;
 function splitMembers(inner) {
   return splitTopLevel(inner, ",").map((part) => {
     const match = TYPE_PREFIX.exec(part);
@@ -251,7 +252,7 @@ function parseImport(statement) {
   };
 }
 function extractImportBlock(text) {
-  const firstRe = /(?:^|\n)(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)[ \t]*\n)*[ \t]*import\b/;
+  const firstRe = /(?:^|\n)(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)[ \t]*\n)*[ \t]*import\b(?![.(])/;
   const first = firstRe.exec(text);
   if (!first) {
     return null;
@@ -260,7 +261,7 @@ function extractImportBlock(text) {
 ` ? 1 : 0);
   const statements = [];
   const skipRe = /(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)?[ \t]*\n)*/y;
-  const importRe = /[ \t]*(import\b[\s\S]*?(?:from\s*(['"])[^'"]+\2|(['"])[^'"]+\3)(?:\s+with\s*\{[^}]*\})?\s*;?)/y;
+  const importRe = /[ \t]*(import\b(?![.(])[\s\S]*?(?:from\s*(['"])[^'"]+\2|(['"])[^'"]+\3)(?:\s+with\s*\{[^}]*\})?\s*;?)/y;
   let cursor = start;
   while (cursor < text.length) {
     skipRe.lastIndex = cursor;
@@ -279,9 +280,6 @@ function extractImportBlock(text) {
     const leadingLines = [];
     for (let i = commentLines.length - 1;i >= 0; i--) {
       const line = commentLines[i];
-      if (line === undefined) {
-        continue;
-      }
       if (line.trim() === "") {
         break;
       }
@@ -338,7 +336,7 @@ function normalizeTypeClause(importDecl) {
   };
 }
 function mergeImportsFromSameSource(imports) {
-  const indexBySource = new Map;
+  const indexByKey = new Map;
   const result = [];
   for (const rawImport of imports) {
     const importDecl = normalizeTypeClause(rawImport);
@@ -346,9 +344,10 @@ function mergeImportsFromSameSource(imports) {
       result.push(importDecl);
       continue;
     }
-    const existingIndex = indexBySource.get(importDecl.source);
+    const mergeKey = `${importDecl.source}\x00${importDecl.attributes ?? ""}`;
+    const existingIndex = indexByKey.get(mergeKey);
     if (existingIndex === undefined) {
-      indexBySource.set(importDecl.source, result.length);
+      indexByKey.set(mergeKey, result.length);
       result.push(importDecl);
       continue;
     }
@@ -360,7 +359,7 @@ function mergeImportsFromSameSource(imports) {
       defaultSpec: existing.defaultSpec ?? importDecl.defaultSpec,
       namespaceSpec: existing.namespaceSpec ?? importDecl.namespaceSpec,
       members: existing.members === null && importDecl.members === null ? null : [...existing.members ?? [], ...importDecl.members ?? []],
-      attributes: existing.attributes ?? importDecl.attributes,
+      attributes: existing.attributes,
       leadingComments: existing.leadingComments
     };
   }
@@ -376,9 +375,9 @@ function applyTypeImports(importDecl, style) {
     }
     const typeMembers2 = importDecl.members.filter((member) => member.isType);
     const valueMembers2 = importDecl.members.filter((member) => !member.isType);
-    const out = [];
+    const output = [];
     if (typeMembers2.length > 0) {
-      out.push({
+      output.push({
         source: importDecl.source,
         typeClause: true,
         sideEffect: false,
@@ -391,13 +390,13 @@ function applyTypeImports(importDecl, style) {
     }
     const hasValueBody = valueMembers2.length > 0 || importDecl.defaultSpec !== null || importDecl.namespaceSpec !== null;
     if (hasValueBody) {
-      out.push({
+      output.push({
         ...importDecl,
         members: valueMembers2.length > 0 ? sortMembersAlpha(valueMembers2) : null,
         leadingComments: typeMembers2.length > 0 ? "" : importDecl.leadingComments
       });
     }
-    return out.length > 0 ? out : [importDecl];
+    return output.length > 0 ? output : [importDecl];
   }
   const inlineBase = importDecl.typeClause ? {
     ...importDecl,
@@ -422,8 +421,8 @@ function sortSegment(imports, options2, groupIndex, fallback) {
     return [];
   }
   const style = options2.importOrderTypeImports;
-  const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(imports) : imports;
-  const rewritten = deduped.flatMap((importDecl) => applyTypeImports(importDecl, style));
+  const deduplicated = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(imports) : imports;
+  const rewritten = deduplicated.flatMap((importDecl) => applyTypeImports(importDecl, style));
   const decorated = rewritten.map((importDecl, index) => ({
     importDecl,
     group: detectGroup(importDecl.source),
@@ -506,9 +505,10 @@ function sortImports(text, rawOptions) {
   const replacement = allLines.join(`
 `);
   const trailing = text.slice(block.end);
-  const suffix = trailing.trim() ? `
+  const nonBlankIndex = trailing.search(/\S/);
+  const suffix = nonBlankIndex >= 0 ? `
 
-` + trailing.trimStart() : trailing;
+` + trailing.slice(nonBlankIndex) : trailing;
   return text.slice(0, block.start) + replacement + suffix;
 }
 
@@ -633,8 +633,6 @@ var DEPENDENCY_FIELDS = [
   "devDependencies",
   "peerDependencies",
   "optionalDependencies",
-  "bundledDependencies",
-  "bundleDependencies",
   "resolutions",
   "overrides"
 ];
@@ -646,8 +644,8 @@ function isPlainObject(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function sortObjectKeysByOrder(record, order) {
-  const orderIndex = new Map(order.map((key, index) => [key, index]));
+var TOP_LEVEL_ORDER_INDEX = new Map(PACKAGE_JSON_TOP_LEVEL_ORDER.map((key, index) => [key, index]));
+function sortObjectKeysByOrder(record, orderIndex) {
   const known = [];
   const rest = [];
   for (const entry of Object.entries(record)) {
@@ -671,6 +669,9 @@ function sortObjectKeysAlpha(value) {
 function sortStringArrayAlpha(value) {
   return [...value].sort((a, b) => a.localeCompare(b, "en"));
 }
+function uniqueStringArray(value) {
+  return [...new Set(value)];
+}
 function isPackageJson(filepath) {
   if (!filepath) {
     return false;
@@ -681,6 +682,116 @@ function detectIndent(source) {
   const match = /\n([ \t]+)\S/.exec(source);
   return match ? match[1] ?? "  " : "  ";
 }
+var DEFAULT_NPM_SCRIPTS = new Set([
+  "install",
+  "pack",
+  "prepare",
+  "publish",
+  "restart",
+  "shrinkwrap",
+  "start",
+  "stop",
+  "test",
+  "uninstall",
+  "version"
+]);
+var RUN_S_PATTERN = /(?<=^|[\s&;<>|(])(?:run-s|npm-run-all2? .*(?:--sequential|--serial|-s))(?=$|[\s&;<>|)])/;
+function hasSequentialScript(packageObject) {
+  const devDependencies = packageObject["devDependencies"];
+  if (!isPlainObject(devDependencies) || !Object.hasOwn(devDependencies, "npm-run-all") && !Object.hasOwn(devDependencies, "npm-run-all2")) {
+    return false;
+  }
+  const scriptCommands = ["scripts", "betterScripts"].flatMap((field) => {
+    const scriptsObject = packageObject[field];
+    return isPlainObject(scriptsObject) ? Object.values(scriptsObject) : [];
+  });
+  return scriptCommands.some((script) => typeof script === "string" && script.includes("*") && RUN_S_PATTERN.test(script));
+}
+function sortScriptNames(keys, prefix = "") {
+  const groupMap = new Map;
+  for (const key of keys) {
+    const rest = prefix ? key.slice(prefix.length + 1) : key;
+    const colonIndex = rest.indexOf(":");
+    if (colonIndex > 0) {
+      const base = key.slice(0, (prefix ? prefix.length + 1 : 0) + colonIndex);
+      let group = groupMap.get(base);
+      if (!group) {
+        group = [];
+        groupMap.set(base, group);
+      }
+      group.push(key);
+    } else {
+      let group = groupMap.get(key);
+      if (!group) {
+        group = [];
+        groupMap.set(key, group);
+      }
+      group.push(key);
+    }
+  }
+  return [...groupMap.keys()].sort((a, b) => a.localeCompare(b, "en")).flatMap((groupKey) => {
+    const children = groupMap.get(groupKey);
+    if (children.length > 1 && children.some((key) => key !== groupKey && key.startsWith(groupKey + ":"))) {
+      const direct = children.filter((key) => key === groupKey || !key.startsWith(groupKey + ":")).sort((a, b) => a.localeCompare(b, "en"));
+      const nested = children.filter((key) => key.startsWith(groupKey + ":"));
+      return [...direct, ...sortScriptNames(nested, groupKey)];
+    }
+    return children.sort((a, b) => a.localeCompare(b, "en"));
+  });
+}
+function sortScripts(scripts, packageObject) {
+  const names = Object.keys(scripts);
+  const prefixable = new Set;
+  const normalized = names.map((name) => {
+    const base = name.replace(/^(?:pre|post)/, "");
+    if (DEFAULT_NPM_SCRIPTS.has(base) || names.includes(base)) {
+      prefixable.add(base);
+      return base;
+    }
+    return name;
+  });
+  let sortedNames;
+  if (hasSequentialScript(packageObject)) {
+    sortedNames = [...new Set(normalized)];
+  } else {
+    sortedNames = sortScriptNames(normalized);
+  }
+  const orderedNames = sortedNames.flatMap((key) => prefixable.has(key) ? [`pre${key}`, key, `post${key}`] : [key]);
+  return Object.fromEntries(orderedNames.filter((name) => Object.hasOwn(scripts, name)).map((name) => [name, scripts[name]]));
+}
+function sortExportsField(exports) {
+  const keys = Object.keys(exports);
+  const paths = keys.filter((key) => key.startsWith(".")).sort();
+  const conditions = keys.filter((key) => !key.startsWith(".")).sort();
+  const defaultIndex = conditions.indexOf("default");
+  if (defaultIndex >= 0) {
+    conditions.splice(defaultIndex, 1);
+    conditions.push("default");
+  }
+  const orderedKeys = [...paths, ...conditions];
+  return Object.fromEntries(orderedKeys.map((key) => {
+    const value = exports[key];
+    return [
+      key,
+      isPlainObject(value) ? sortExportsField(value) : value
+    ];
+  }));
+}
+var UNIQUE_ONLY_FIELDS = new Set(["keywords", "files", "activationEvents"]);
+var UNIQUE_AND_SORT_FIELDS = new Set([
+  "bundledDependencies",
+  "bundleDependencies",
+  "extensionPack",
+  "extensionDependencies"
+]);
+var NO_SORT_ARRAY_FIELDS = new Set(["workspaces"]);
+function detectNewline(source) {
+  const crlfIndex = source.indexOf(`\r
+`);
+  return crlfIndex >= 0 ? `\r
+` : `
+`;
+}
 function sortPackageJson(text, rawOptions) {
   if (!isPackageJson(rawOptions.filepath)) {
     return text;
@@ -704,21 +815,51 @@ function sortPackageJson(text, rawOptions) {
     }
   }
   if (options2.packageJsonOrder) {
-    result = sortObjectKeysByOrder(result, PACKAGE_JSON_TOP_LEVEL_ORDER);
+    result = sortObjectKeysByOrder(result, TOP_LEVEL_ORDER_INDEX);
+    for (const field of ["scripts", "betterScripts"]) {
+      const scriptsValue = result[field];
+      if (scriptsValue !== undefined && isPlainObject(scriptsValue) && !exclude.has(field)) {
+        result[field] = sortScripts(scriptsValue, result);
+      }
+    }
+    const exportsValue = result["exports"];
+    if (exportsValue !== undefined && isPlainObject(exportsValue) && !exclude.has("exports")) {
+      result["exports"] = sortExportsField(exportsValue);
+    }
     for (const [key, value] of Object.entries(result)) {
       if (exclude.has(key)) {
         continue;
       }
-      if (isStringArray(value)) {
-        result[key] = sortStringArrayAlpha(value);
+      if (!isStringArray(value)) {
+        continue;
+      }
+      if (NO_SORT_ARRAY_FIELDS.has(key)) {
+        continue;
+      }
+      if (UNIQUE_ONLY_FIELDS.has(key)) {
+        result[key] = uniqueStringArray(value);
+        continue;
+      }
+      if (UNIQUE_AND_SORT_FIELDS.has(key)) {
+        result[key] = sortStringArrayAlpha(uniqueStringArray(value));
+        continue;
       }
+      result[key] = sortStringArrayAlpha(value);
     }
   }
   const indent = detectIndent(text);
+  const newline = detectNewline(text);
   const output = JSON.stringify(result, null, indent);
-  return text.endsWith(`
-`) ? output + `
-` : output;
+  if (text.endsWith(newline)) {
+    return newline === `\r
+` ? output.replace(/\n/g, `\r
+`) + `\r
+` : output + `
+`;
+  }
+  return newline === `\r
+` ? output.replace(/\n/g, `\r
+`) : output;
 }
 
 // src/index.ts

package/dist/options.d.ts

@@ -0,0 +1,26 @@
+import { type ParserOptions, type SupportOptions } from 'prettier';
+/** import 分组，参考 eslint-plugin-import 的 import/order 规则。 */
+export type ImportGroup = 'builtin' | 'external' | 'internal' | 'parent' | 'sibling' | 'index';
+/** `import type` 内联风格，参考 @typescript-eslint/consistent-type-imports 的 fixStyle 选项。 */
+export type TypeImportsStyle = 'separate' | 'inline-first' | 'inline-last' | 'mixed';
+/** 插件排序配置。 */
+export interface SortOptions {
+    importOrder?: boolean;
+    importOrderGroups?: ImportGroup[];
+    importOrderSeparation?: boolean;
+    importOrderTypeImports?: TypeImportsStyle;
+    importOrderMergeDuplicates?: boolean;
+    exportOrder?: boolean;
+    packageJsonOrder?: boolean;
+    packageJsonOrderExcludeKeys?: string[];
+}
+/** 默认排序配置。 */
+export declare const DEFAULT_SORT_OPTIONS: Required<SortOptions>;
+type RawSortOptions = ParserOptions & Partial<SortOptions>;
+/**
+ * 从 Prettier 选项中提取插件配置，缺失或非法的参数会回退为默认值。
+ */
+export declare function resolveSortOptions(rawOptions: RawSortOptions): Required<SortOptions>;
+/** 注册到 Prettier 的选项定义。使用功能名词前缀命名，因为 Prettier API 不支持嵌套的选项对象。 */
+export declare const options: SupportOptions;
+export {};

package/dist/order-package.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `package.json` 顶层字段的排列顺序。
+ * 参考社区标准 sort-package-json 的字段列表：https://github.com/keithamus/sort-package-json/blob/main/index.js#L433-L564
+ */
+export declare const PACKAGE_JSON_TOP_LEVEL_ORDER: readonly string[];
+/**
+ * 值为 `{ name: range }` 映射的依赖表字段。
+ * 始终按字母序排列，不受用户选项影响——npm install 每次都会按字母序重写。
+ */
+export declare const DEPENDENCY_FIELDS: readonly string[];

package/dist/sort-exports.d.ts

@@ -0,0 +1,12 @@
+import { type ParserOptions } from 'prettier';
+/**
+ * 按字母序排列 `export { … }` 花括号内的命名导出。
+ * 不改变语句位置，不跨语句合并，只针对单条 export 语句的花括号内部。
+ *
+ * 覆盖的语法形式：
+ *   export { a, b };
+ *   export { a, b } from 'mod';
+ *   export type { A, B };
+ *   export type { A, B } from 'mod';
+ */
+export declare function sortExports(text: string, rawOptions: ParserOptions): string;

package/dist/sort-imports.d.ts

@@ -0,0 +1,2 @@
+import { type ParserOptions } from 'prettier';
+export declare function sortImports(text: string, rawOptions: ParserOptions): string;

package/dist/sort-package.d.ts

@@ -0,0 +1,2 @@
+import { type ParserOptions } from 'prettier';
+export declare function sortPackageJson(text: string, rawOptions: ParserOptions): string;

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 按 `separator` 分割字符串，忽略嵌套在 `{}` / `()` / `[]` 中的分隔符。
+ * 仅在顶层（深度为 0 的位置）分隔。返回结果会 trim 并剔除空段。
+ *
+ * 不使用 `String.prototype.split` 直接分隔，因为 import / export 的花括号内可能
+ * 出现形如 `{ a, b as c }`，其中嵌套结构内的逗号不应被当作分隔符。
+ */
+export declare function splitTopLevel(input: string, separator: string): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sort",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "An all-in-one Prettier plugin to sort imports, package.json keys, and more.",
   "keywords": [
     "imports",
@@ -35,24 +35,25 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun run scripts/build/index.ts",
-    "format": "prettier \"{src,scripts}/**/*.ts\" \"*.ts\" --write",
-    "lint": "eslint \"{src,scripts}/**/*.ts\" \"*.ts\"",
+    "build": "bun run scripts/build/",
+    "format": "prettier **/*.ts --write",
+    "lint": "eslint **/*.ts",
     "prepare": "husky",
-    "test": "bun test"
+    "test": "bun test scripts/test/",
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.5.0",
-    "@commitlint/config-conventional": "^20.5.0",
-    "@commitlint/types": "^20.5.0",
+    "@commitlint/cli": "^21.0.1",
+    "@commitlint/config-conventional": "^21.0.1",
+    "@commitlint/types": "^21.0.1",
     "@eslint/js": "^10.0.1",
-    "@types/bun": "^1.3.13",
-    "bun-plugin-dts": "^0.4.0",
-    "eslint": "^10.2.1",
+    "@types/bun": "^1.3.14",
+    "annal": "^0.0.2",
+    "eslint": "^10.4.0",
     "husky": "^9.1.7",
     "prettier": "^3.8.3",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.0"
+    "typescript-eslint": "^8.59.3"
   },
   "peerDependencies": {
     "prettier": ">=3.0.0"