chore: wip

Author: chrisbbreuer

docs/advanced/plugin-system.md

@@ -29,7 +29,7 @@ export default config
 
 Built-in plugins and rules (see the Rules section for details):
 
-- `pickier`: [`sort-objects`](/rules/pickier-sort-objects), [`sort-imports`](/rules/pickier-sort-imports), [`sort-named-imports`](/rules/pickier-sort-named-imports), [`sort-heritage-clauses`](/rules/pickier-sort-heritage-clauses), [`sort-keys`](/rules/sort-keys), [`sort-exports`](/rules/sort-exports), [`no-unused-vars`](/rules/no-unused-vars), [`prefer-const`](/rules/prefer-const)
+- `pickier`: [`no-unused-vars`](/rules/no-unused-vars), [`prefer-const`](/rules/prefer-const), [`sort-array-includes`](/rules/sort-array-includes), [`sort-classes`](/rules/sort-classes), [`sort-enums`](/rules/sort-enums), [`sort-exports`](/rules/sort-exports), [`sort-heritage-clauses`](/rules/pickier-sort-heritage-clauses), [`sort-imports`](/rules/pickier-sort-imports), [`sort-interfaces`](/rules/sort-interfaces), [`sort-keys`](/rules/sort-keys), [`sort-maps`](/rules/sort-maps), [`sort-named-imports`](/rules/pickier-sort-named-imports), [`sort-object-types`](/rules/sort-object-types), [`sort-objects`](/rules/pickier-sort-objects)
 - `style`: [`max-statements-per-line`](/rules/style-max-statements-per-line)
 - `regexp`: [`no-super-linear-backtracking`](/rules/regexp-no-super-linear-backtracking)
 

docs/rules/overview.md

@@ -16,16 +16,22 @@ Core:
 
 Plugin:
 
-- [`sort-objects`](/rules/pickier-sort-objects)
-- [`sort-imports`](/rules/pickier-sort-imports)
-- [`sort-named-imports`](/rules/pickier-sort-named-imports)
-- [`sort-heritage-clauses`](/rules/pickier-sort-heritage-clauses)
-- [`sort-keys`](/rules/sort-keys)
-- [`sort-exports`](/rules/sort-exports)
 - [`max-statements-per-line`](/rules/style-max-statements-per-line)
-- [`pickier/no-unused-vars`](/rules/no-unused-vars)
 - [`no-super-linear-backtracking`](/rules/regexp-no-super-linear-backtracking)
+- [`no-unused-vars`](/rules/no-unused-vars)
 - [`prefer-const`](/rules/prefer-const)
+- [`sort-array-includes`](/rules/sort-array-includes)
+- [`sort-classes`](/rules/sort-classes)
+- [`sort-enums`](/rules/sort-enums)
+- [`sort-exports`](/rules/sort-exports)
+- [`sort-heritage-clauses`](/rules/pickier-sort-heritage-clauses)
+- [`sort-imports`](/rules/pickier-sort-imports)
+- [`sort-interfaces`](/rules/sort-interfaces)
+- [`sort-keys`](/rules/sort-keys)
+- [`sort-maps`](/rules/sort-maps)
+- [`sort-named-imports`](/rules/pickier-sort-named-imports)
+- [`sort-object-types`](/rules/sort-object-types)
+- [`sort-objects`](/rules/pickier-sort-objects)
 
 Groups:
 

docs/rules/pickier.md

@@ -2,13 +2,19 @@
 
 Rules provided by the built-in `pickier` plugin. These focus on layout, sorting, and practical hygiene checks.
 
-- [`sort-objects`](/rules/pickier-sort-objects): require object literal keys to be sorted
-- [`sort-imports`](/rules/pickier-sort-imports): enforce canonical ordering/grouping of the import block
-- [`sort-named-imports`](/rules/pickier-sort-named-imports): sort named specifiers within a single import statement
-- [`sort-heritage-clauses`](/rules/pickier-sort-heritage-clauses): sort TypeScript `extends`/`implements` lists
-- [`sort-keys`](/rules/sort-keys): ESLint-like object key sort check
-- [`sort-exports`](/rules/sort-exports): sort contiguous export statements
 - [`no-unused-vars`](/rules/no-unused-vars): report variables/parameters that are declared but never used
 - [`prefer-const`](/rules/prefer-const): suggest `const` for variables that are never reassigned
+- [`sort-array-includes`](/rules/sort-array-includes): enforce sorted array literals immediately used with `.includes(...)`
+- [`sort-classes`](/rules/sort-classes): enforce sorted class members
+- [`sort-enums`](/rules/sort-enums): enforce sorted enum members
+- [`sort-exports`](/rules/sort-exports): sort contiguous export statements
+- [`sort-heritage-clauses`](/rules/pickier-sort-heritage-clauses): sort TypeScript `extends`/`implements` lists
+- [`sort-imports`](/rules/pickier-sort-imports): enforce canonical ordering/grouping of the import block
+- [`sort-interfaces`](/rules/sort-interfaces): enforce sorted TypeScript interface members
+- [`sort-keys`](/rules/sort-keys): ESLint-like object key sort check
+- [`sort-maps`](/rules/sort-maps): enforce sorted entries inside `new Map([...])`
+- [`sort-named-imports`](/rules/pickier-sort-named-imports): sort named specifiers within a single import statement
+- [`sort-object-types`](/rules/sort-object-types): enforce sorted TypeScript object type members
+- [`sort-objects`](/rules/pickier-sort-objects): require object literal keys to be sorted
 
 See the [Plugin System](/advanced/plugin-system) for configuration examples.

docs/rules/sort-array-includes.md

@@ -0,0 +1,71 @@
+# sort-array-includes
+
+Enforce sorted array values when immediately used with `.includes(...)`.
+
+Keeping arrays sorted improves scanability and reduces mistakes in membership checks.
+
+## Config
+
+```ts
+pluginRules: {
+  sort-array-includes: [warn, { type: alphabetical, order: asc, ignoreCase: true }],
+}
+```
+
+Options:
+
+- `type`: alphabetical | natural | line-length | custom | unsorted (default: alphabetical)
+- `order`: asc | desc (default: asc)
+- `ignoreCase`: boolean (default: true)
+- `specialCharacters`: keep | trim | remove (default: keep)
+- `alphabet`: string (default: ) — only when type=custom
+- `partitionByNewLine`: boolean (default: false)
+
+Note: Heuristic detection; focuses on literal arrays directly followed by `.includes(...)`.
+
+## Example
+
+Before:
+
+```ts
+function getProductCategories(product) {
+  if ([
+    Mouse,
+    Drone,
+    Smartphone,
+    Keyboard,
+    Tablet,
+    Monitor,
+    Laptop,
+    Smartwatch,
+    Router,
+    Headphones,
+  ].includes(product.name)) {
+    return Electronics
+  }
+  return Unknown
+}
+```
+
+After (alphabetical asc):
+
+```ts
+if ([
+  Drone,
+  Headphones,
+  Keyboard,
+  Laptop,
+  Monitor,
+  Mouse,
+  Router,
+  Smartphone,
+  Smartwatch,
+  Tablet,
+].includes(product.name)) { /* ... */ }
+```
+
+## Best practices
+
+- Use `natural` when values include numeric suffixes (e.g., `item2`, `item10`)
+- Consider `partitionByNewLine: true` to preserve logical grouping inside long arrays
+- Keep at `warn` to surface unsorted lists without blocking

docs/rules/sort-classes.md

@@ -0,0 +1,89 @@
+# sort-classes
+
+Enforce sorted class members.
+
+Organizing class members in a consistent order improves readability and maintainability. This rule helps developers quickly locate class members and understand the overall structure of the class.
+
+## Config
+
+```ts
+pluginRules: {
+  sort-classes: [warn, { type: alphabetical, order: asc, ignoreCase: true }],
+}
+```
+
+Options:
+
+- `type`: alphabetical | natural | line-length | custom | unsorted (default: alphabetical)
+- `order`: asc | desc (default: asc)
+- `ignoreCase`: boolean (default: true)
+- `specialCharacters`: keep | trim | remove (default: keep)
+- `alphabet`: string (default: ) — only when type=custom
+- `partitionByNewLine`: boolean (default: false) — respect blank-line groups and do not sort across them
+
+Note: This is a heuristic rule; it does not parse full TypeScript syntax trees.
+
+## Example
+
+Before:
+
+```ts
+class User {
+  constructor(username: string, email: string, isActive: boolean) {
+    this.username = username
+    this.email = email
+    this.isActive = isActive
+    this.roles = []
+  }
+
+  addRole(role: string) {
+    this.roles.push(role)
+  }
+
+  deactivate() {
+    this.isActive = false
+  }
+
+  setEmail(newEmail: string) {
+    this.email = newEmail
+  }
+
+  activate() {
+    this.isActive = true
+  }
+
+  removeRole(role: string) {
+    this.roles = this.roles.filter(r => r !== role)
+  }
+
+  getProfile() {
+    return {
+      username: this.username,
+      email: this.email,
+      isActive: this.isActive,
+      roles: this.roles,
+    }
+  }
+}
+```
+
+After (alphabetical asc):
+
+```ts
+class User {
+  activate() { this.isActive = true }
+  addRole(role: string) { this.roles.push(role) }
+  constructor(username: string, email: string, isActive: boolean) { /* ... */ }
+  deactivate() { this.isActive = false }
+  getProfile() { /* ... */ }
+  removeRole(role: string) { /* ... */ }
+  setEmail(newEmail: string) { /* ... */ }
+}
+```
+
+## Best practices
+
+- Choose `natural` when member names include numeric suffixes (e.g., `step2`, `step10`)
+- Use `partitionByNewLine: true` to preserve intentional manual grouping
+- Keep the rule at `warn` initially to catch problematic cases without blocking
+- Combine with code review guidelines for constructor-first or accessors-first conventions as needed

docs/rules/sort-enums.md

@@ -0,0 +1,59 @@
+# sort-enums
+
+Enforce sorted TypeScript enum members.
+
+Keeping enum members in a consistent and predictable order improves readability and maintainability.
+
+## Config
+
+```ts
+pluginRules: {
+  sort-enums: [warn, { type: alphabetical, order: asc, ignoreCase: true }],
+}
+```
+
+Options:
+
+- `type`: alphabetical | natural | line-length | custom | unsorted (default: alphabetical)
+- `order`: asc | desc (default: asc)
+- `ignoreCase`: boolean (default: true)
+- `specialCharacters`: keep | trim | remove (default: keep)
+- `alphabet`: string (default: ) — only when type=custom
+- `partitionByNewLine`: boolean (default: false)
+- `sortByValue`: boolean (default: false) — sort by enum values (names by default)
+- `forceNumericSort`: boolean (default: false) — numeric enums sorted numerically regardless of type/order
+
+Note: This is a heuristic rule; it does not parse full TypeScript syntax trees.
+
+## Example
+
+Before:
+
+```ts
+enum Priority {
+  Critical = Critical,
+  None = None,
+  Low = Low,
+  High = High,
+  Medium = Medium,
+}
+```
+
+After (alphabetical asc by name):
+
+```ts
+enum Priority {
+  Critical = Critical,
+  High = High,
+  Low = Low,
+  Medium = Medium,
+  None = None,
+}
+```
+
+## Best practices
+
+- Use `natural` when enum member names include numeric suffixes
+- Enable `sortByValue` when values matter more than names (e.g., localized strings)
+- Use `partitionByNewLine: true` to keep logical groups intact
+- Pair with code review expectations for enum organization (e.g., status enums grouped by lifecycle)

docs/rules/sort-interfaces.md

@@ -0,0 +1,62 @@
+# sort-interfaces
+
+Enforce sorted TypeScript interface properties.
+
+Sorting interface properties provides a clear and predictable structure, improving readability and maintenance. Property comments and documentation remain adjacent to their properties when sorted by this rule.
+
+## Config
+
+```ts
+pluginRules: {
+  sort-interfaces: [warn, { type: alphabetical, order: asc, ignoreCase: true }],
+}
+```
+
+Options:
+
+- `type`: alphabetical | natural | line-length | custom | unsorted (default: alphabetical)
+- `order`: asc | desc (default: asc)
+- `ignoreCase`: boolean (default: true)
+- `specialCharacters`: keep | trim | remove (default: keep)
+- `alphabet`: string (default: ) — only when type=custom
+- `partitionByNewLine`: boolean (default: false)
+- `sortBy`: name | value (default: name) — sort by property names or by their value types
+
+Note: Heuristic detection focusing on single-line property and method signatures.
+
+## Example
+
+Before:
+
+```ts
+interface User {
+  firstName: string
+  email: string
+  roles: string[]
+  login: string
+  phoneNumber?: string
+  address: Address
+  id: string
+}
+```
+
+After (alphabetical asc):
+
+```ts
+interface User {
+  address: Address
+  email: string
+  firstName: string
+  id: string
+  login: string
+  phoneNumber?: string
+  roles: string[]
+}
+```
+
+## Best practices
+
+- Prefer `natural` when keys include numbers (e.g., `field2`, `field10`)
+- Use `partitionByNewLine: true` to preserve logical grouping (e.g., identification vs. metadata)
+- Consider `sortBy: value` to group by type when helpful (e.g., all `string` fields together)
+- Avoid combining with adjacent-overload-signatures rules to prevent conflicts