feat: add sort-export-attributes rule

Author: azat-io

docs/content/rules/sort-export-attributes.mdx

@@ -0,0 +1,275 @@
+---
+title: sort-export-attributes
+description: Keep export attributes consistently ordered for clearer, more maintainable exports. This rule sorts attributes defined with the export attributes syntax
+shortDescription: Enforce sorted export attributes
+keywords:
+  - eslint
+  - sort export attributes
+  - export attributes
+  - eslint rule
+  - coding standards
+  - code quality
+  - javascript linting
+---
+
+import CodeExample from '../../components/CodeExample.svelte'
+import CodeTabs from '../../components/CodeTabs.svelte'
+import dedent from 'dedent'
+
+Enforce sorted export attributes.
+
+This rule keeps attributes inside `export ... with { ... }` consistently ordered. It improves readability, makes diffs smaller, and keeps attribute groups tidy in larger files.
+
+## Try it out
+
+<CodeExample
+  alphabetical={dedent`
+    export { data } from 'lib' with {
+      integrity: 'sha256-...',
+      mode: 'no-cors',
+      type: 'json',
+    }
+  `}
+  lineLength={dedent`
+    export { data } from 'lib' with {
+      integrity: 'sha256-...',
+      mode: 'no-cors',
+      type: 'json',
+    }
+  `}
+  initial={dedent`
+    export { data } from 'lib' with {
+      mode: 'no-cors',
+      type: 'json',
+      integrity: 'sha256-...',
+    }
+  `}
+  client:load
+  lang="tsx"
+/>
+
+## Options
+
+This rule accepts an options object with the following properties:
+
+### type
+
+<sub>default: `'alphabetical'`</sub>
+
+Specifies the sorting method.
+
+- `'alphabetical'` — Sort attributes alphabetically using [localeCompare](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare).
+- `'natural'` — Sort by [natural](https://github.com/yobacca/natural-orderby) order (e.g., `link2` < `link10`).
+- `'line-length'` — Sort by attribute name length (shorter first by default).
+- `'custom'` — Sort using a custom alphabet specified in [`alphabet`](#alphabet).
+- `'unsorted'` — Do not sort items. [`grouping`](#groups) and [`newlines behavior`](#newlinesbetween) are still enforced.
+
+### order
+
+<sub>default: `'asc'`</sub>
+
+Sort direction.
+
+- `'asc'` — Ascending (A→Z, short→long).
+- `'desc'` — Descending (Z→A, long→short).
+
+### fallbackSort
+
+<sub>
+  type:
+  ```ts
+  {
+    type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted'
+    order?: 'asc' | 'desc'
+  }
+  ```
+</sub>
+<sub>default: `{ type: 'unsorted' }`</sub>
+
+Fallback sorting used when the primary comparison results are equal.
+
+Example: ensure alphabetical tiebreak for equal name lengths.
+```ts
+{
+  type: 'line-length',
+  order: 'desc',
+  fallbackSort: { type: 'alphabetical', order: 'asc' }
+}
+```
+
+### alphabet
+
+<sub>default: `''`</sub>
+
+Used only when [`type`](#type) is `'custom'`. Defines the custom character order.
+
+### ignoreCase
+
+<sub>default: `true`</sub>
+
+Whether to perform case-insensitive comparison for string-based sorts.
+
+### specialCharacters
+
+<sub>default: `'keep'`</sub>
+
+How to handle special characters before comparison.
+
+- `'keep'` — Keep as-is.
+- `'trim'` — Trim leading special characters.
+- `'remove'` — Remove all special characters.
+
+### locales
+
+<sub>default: `'en-US'`</sub>
+
+Locales passed to `localeCompare` for alphabetical/natural sorts.
+
+### partitionByComment
+
+<sub>default: `false`</sub>
+
+Use comments to split attributes into independent partitions that are sorted separately.
+
+- `true` — Any non-ESLint comment creates a partition.
+- `false` — Ignore comments for partitioning.
+- `RegExpPattern = string | { pattern: string; flags?: string }` — Pattern for matching comments.
+- `RegExpPattern[]` — List of patterns.
+- `{ block: boolean | RegExpPattern | RegExpPattern[]; line: boolean | RegExpPattern | RegExpPattern[] }` — Separate settings for block/line comments.
+
+### partitionByNewLine
+
+<sub>default: `false`</sub>
+
+When `true`, an empty line between attributes creates a partition. Each partition is sorted independently.
+
+### newlinesBetween
+
+<sub>type: `number | 'ignore' | 'always' | 'never'`</sub>
+<sub>default: `'ignore'`</sub>
+
+Controls newlines between groups:
+
+- `'ignore'` — Do not report spacing issues.
+- `'always'` — Require a blank line between groups, forbid blank lines inside a group.
+- `'never'` — Forbid blank lines between groups.
+- `number` — Require exactly that many newlines between groups; forbid inside a group.
+
+### groups
+
+<sub>default: `[]`</sub>
+
+Defines the order of attribute groups. Unknown attributes are placed after the last group.
+
+You can mix predefined (none for this rule) and custom groups. Typical usage is with custom groups declared via `elementNamePattern`.
+
+Example: put any attribute starting with `type` before others, and require a newline between groups.
+
+```ts
+groups: ['type-attrs', 'unknown']
+customGroups: [
+  { groupName: 'type-attrs', elementNamePattern: '^type' },
+]
+newlinesBetween: 'always'
+```
+
+### customGroups
+
+Define custom attribute groups with optional per-group sort overrides.
+
+```ts
+type CustomGroup = {
+  groupName: string
+  // Match by attribute name
+  elementNamePattern?: string | string[] | { pattern: string; flags?: string } | { pattern: string; flags?: string }[]
+
+  // Optional per-group overrides:
+  type?: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted'
+  order?: 'asc' | 'desc'
+  fallbackSort?: { type: string; order?: 'asc' | 'desc' }
+  newlinesInside?: 'always' | 'never' | number
+}[]
+```
+
+An attribute matches a custom group when its name satisfies `elementNamePattern`. The first matching definition wins.
+
+## Usage
+
+<CodeTabs
+  code={[
+    {
+      source: dedent`
+        // eslint.config.js
+        import perfectionist from 'eslint-plugin-perfectionist'
+
+        export default [
+          {
+            plugins: { perfectionist },
+            rules: {
+              'perfectionist/sort-export-attributes': [
+                'error',
+                {
+                  type: 'alphabetical',
+                  order: 'asc',
+                  fallbackSort: { type: 'unsorted' },
+                  ignoreCase: true,
+                  specialCharacters: 'keep',
+                  locales: 'en-US',
+                  alphabet: '',
+                  partitionByComment: false,
+                  partitionByNewLine: false,
+                  newlinesBetween: 'ignore',
+                  groups: [],
+                  customGroups: [],
+                },
+              ],
+            },
+          },
+        ]
+      `,
+      name: 'Flat Config',
+      value: 'flat',
+    },
+    {
+      source: dedent`
+        // .eslintrc.js
+        module.exports = {
+          plugins: ['perfectionist'],
+          rules: {
+            'perfectionist/sort-export-attributes': [
+              'error',
+              {
+                type: 'alphabetical',
+                order: 'asc',
+                fallbackSort: { type: 'unsorted' },
+                ignoreCase: true,
+                specialCharacters: 'keep',
+                locales: 'en-US',
+                alphabet: '',
+                partitionByComment: false,
+                partitionByNewLine: false,
+                newlinesBetween: 'ignore',
+                groups: [],
+                customGroups: [],
+              },
+            ],
+          },
+        }
+      `,
+      name: 'Legacy Config',
+      value: 'legacy',
+    },
+  ]}
+  type="config-type"
+  client:load
+  lang="tsx"
+/>
+
+## Version
+
+This rule was introduced in [v5.0.0](https://github.com/azat-io/eslint-plugin-perfectionist/releases/tag/v5.0.0).
+
+## Resources
+
+- [Rule source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/rules/sort-export-attributes.ts)
+- [Test source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/test/rules/sort-export-attributes.test.ts)

index.ts

@@ -4,6 +4,7 @@ import { version as packageVersion, name as packageName } from './package.json'
 import sortVariableDeclarations from './rules/sort-variable-declarations'
 import sortIntersectionTypes from './rules/sort-intersection-types'
 import sortImportAttributes from './rules/sort-import-attributes'
+import sortExportAttributes from './rules/sort-export-attributes'
 import sortHeritageClauses from './rules/sort-heritage-clauses'
 import sortArrayIncludes from './rules/sort-array-includes'
 import sortNamedImports from './rules/sort-named-imports'
@@ -28,6 +29,7 @@ interface PluginConfig {
     'sort-variable-declarations': Rule.RuleModule
     'sort-intersection-types': Rule.RuleModule
     'sort-import-attributes': Rule.RuleModule
+    'sort-export-attributes': Rule.RuleModule
     'sort-heritage-clauses': Rule.RuleModule
     'sort-array-includes': Rule.RuleModule
     'sort-named-imports': Rule.RuleModule
@@ -75,6 +77,7 @@ let plugin = {
     'sort-variable-declarations': sortVariableDeclarations,
     'sort-intersection-types': sortIntersectionTypes,
     'sort-import-attributes': sortImportAttributes,
+    'sort-export-attributes': sortExportAttributes,
     'sort-heritage-clauses': sortHeritageClauses,
     'sort-array-includes': sortArrayIncludes,
     'sort-named-imports': sortNamedImports,

readme.md

@@ -179,6 +179,7 @@ module.exports = {
 | [sort-classes](https://perfectionist.dev/rules/sort-classes)                             | Enforce sorted classes                        | 🔧  |
 | [sort-decorators](https://perfectionist.dev/rules/sort-decorators)                       | Enforce sorted decorators                     | 🔧  |
 | [sort-enums](https://perfectionist.dev/rules/sort-enums)                                 | Enforce sorted TypeScript enums               | 🔧  |
+| [sort-export-attributes](https://perfectionist.dev/rules/sort-export-attributes)         | Enforce sorted export attributes              | 🔧  |
 | [sort-exports](https://perfectionist.dev/rules/sort-exports)                             | Enforce sorted exports                        | 🔧  |
 | [sort-heritage-clauses](https://perfectionist.dev/rules/sort-heritage-clauses)           | Enforce sorted `implements`/`extends` clauses | 🔧  |
 | [sort-import-attributes](https://perfectionist.dev/rules/sort-import-attributes)         | Enforce sorted import attributes              | 🔧  |