feat: allow type overrides in groups option

Author: hugop95

docs/content/rules/sort-array-includes.mdx

@@ -20,7 +20,6 @@ Enforce sorted array values if the `includes` method is immediately called after
 
 By keeping arrays sorted, developers can quickly scan and verify the values, making the code more predictable and reducing the likelihood of errors. This practice simplifies debugging and enhances the overall clarity of the codebase.
 
-
 ## Try it out
 
 <CodeExample
@@ -316,6 +315,10 @@ Example configuration:
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -338,6 +341,21 @@ Predefined groups are characterized by a selector.
 - `literal` — Array elements that are not spread values.
 - `spread` — Array elements that are spread values.
 
+#### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'literal',
+    { group: 'spread', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
 #### Newlines between groups
 
 You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.

docs/content/rules/sort-classes.mdx

@@ -330,6 +330,10 @@ Without `ignoreCallbackDependenciesPatterns: ['^computed$']`, `role` and `userna
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -598,6 +602,21 @@ abstract class Example extends BaseExample {
 }
 ```
 
+##### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'property',
+    { group: 'method', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
 ##### Newlines between groups
 
 You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.

docs/content/rules/sort-decorators.mdx

@@ -276,6 +276,10 @@ This option is only applicable when [`partitionByNewLine`](#partitionbynewline)
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -297,6 +301,21 @@ Within a given group, members will be sorted according to the `type`, `order`, `
 Individual groups can be combined together by placing them in an array. The order of groups in that array does not matter.
 All members of the groups in the array will be sorted together as if they were part of a single group.
 
+##### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'myCustomGroup1',
+    { group: 'myCustomGroup2', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
 #### Newlines between groups
 
 You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.

docs/content/rules/sort-enums.mdx

@@ -239,6 +239,10 @@ This option is only applicable when [`partitionByNewLine`](#partitionbynewline)
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -254,6 +258,21 @@ Within a given group, members will be sorted according to the `type`, `order`, `
 Individual groups can be combined together by placing them in an array. The order of groups in that array does not matter.
 All members of the groups in the array will be sorted together as if they were part of a single group.
 
+##### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'myCustomGroup1',
+    { group: 'myCustomGroup2', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
 #### Newlines between groups
 
 You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.
@@ -412,4 +431,4 @@ This rule was introduced in [v0.8.0](https://github.com/azat-io/eslint-plugin-pe
 ## Resources
 
 - [Rule source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/rules/sort-enums.ts)
-- [Test source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/test/sort-enums.test.ts)
+- [Test source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/test/rules/sort-enums.test.ts)

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

@@ -164,6 +164,10 @@ Controls newlines between groups:
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -183,6 +187,40 @@ customGroups: [
 newlinesBetween: 'always'
 ```
 
+#### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'myCustomGroup1',
+    { group: 'myCustomGroup2', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
+#### Newlines between groups
+
+You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.
+
+See the [`newlinesBetween`](#newlinesbetween) option.
+
+This feature is only applicable when [`partitionByNewLine`](#partitionbynewline) is `false`.
+
+```ts
+{
+  newlinesBetween: 1,
+  groups: [
+    'a',
+    { newlinesBetween: 0 }, // Overrides the global newlinesBetween option
+    'b',
+  ]
+}
+```
+
 ### customGroups
 
 Define custom attribute groups with optional per-group sort overrides.

docs/content/rules/sort-exports.mdx

@@ -219,7 +219,11 @@ This option is only applicable when [`partitionByNewLine`](#partitionbynewline)
       | string
       | string[]
       | { newlinesBetween: number }
-      | { group: string | string[]; commentAbove: string }
+      | {
+          group: string | string[];
+          commentAbove?: string;
+          type?: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -255,45 +259,47 @@ Example: `type-export`.
 Members that don’t fit into any group specified in the `groups` option will be placed in the `unknown` group. If the `unknown` group is not specified in the `groups` option,
 it will automatically be added to the end of the list.
 
-##### Newlines between groups
-
-You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.
+##### Group with overridden settings
 
-See the [`newlinesBetween`](#newlinesbetween) option.
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
 
-This feature is only applicable when [`partitionByNewLine`](#partitionbynewline) is `false`.
+- `type` — Overrides the [`type`](#type) option for that group.
+- `commentAbove` — Enforces the presence of a comment containing the content of `commentAbove` above the top element of the group.
+  - An error will be raised if no comment containing the content of `commentAbove` is found above the top element of the
+  group.
+  - Auto-fixing will add a comment containing the content of `commentAbove` above the top element of the group.
+  - Auto-fixing will also remove invalid auto-added comments (only comments existing in `commentAbove` objects are
+  considered as auto-removable).
 
 ```ts
 {
-  newlinesBetween: 1,
   groups: [
-    'a',
-    { newlinesBetween: 0 }, // Overrides the global newlinesBetween option
-    'b',
+    { group: 'type-export', commentAbove: 'Type exports' },
+    'myCustomGroup1',
+    { group: 'myCustomGroup2', type: 'unsorted' }, // Elements from this group will not be sorted
   ]
 }
 ```
 
-#### Comment above groups
+##### Newlines between groups
 
-You may place `commentAbove` objects alongside their related group(s) to enforce the presence of a comment containing the
-content of `commentAbove`.
+You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.
+
+See the [`newlinesBetween`](#newlinesbetween) option.
+
+This feature is only applicable when [`partitionByNewLine`](#partitionbynewline) is `false`.
 
 ```ts
 {
+  newlinesBetween: 1,
   groups: [
-    { group: 'type-export', commentAbove: 'Type exports' },
-    { group: 'value-export', commentAbove: 'Value exports' },
+    'a',
+    { newlinesBetween: 0 }, // Overrides the global newlinesBetween option
+    'b',
   ]
 }
 ```
 
-- An error will be raised if no comment containing the content of `commentAbove` is found above the top element of the
-group.
-- Auto-fixing will add a comment containing the content of `commentAbove` above the top element of the group.
-- Auto-fixing will also remove invalid auto-added comments (only comments existing in `commentAbove`
-objects are considered as auto-removable).
-
 ### customGroups
 
 <sub>

docs/content/rules/sort-heritage-clauses.mdx

@@ -189,6 +189,10 @@ This option is only applicable when [`partitionByNewLine`](#partitionbynewline)
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -210,6 +214,21 @@ Within a given group, members will be sorted according to the `type`, `order`, `
 Individual groups can be combined together by placing them in an array. The order of groups in that array does not matter.
 All members of the groups in the array will be sorted together as if they were part of a single group.
 
+#### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'myCustomGroup1',
+    { group: 'myCustomGroup2', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
 #### Newlines between groups
 
 You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.

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

@@ -164,6 +164,10 @@ Controls newlines between groups:
       | string
       | string[]
       | { newlinesBetween: number }
+      | {
+          group: string | string[];
+          type: 'alphabetical' | 'natural' | 'line-length' | 'custom' | 'unsorted';
+        }
     >
   ```
 </sub>
@@ -183,6 +187,40 @@ customGroups: [
 newlinesBetween: 'always'
 ```
 
+#### Group with overridden settings
+
+You may directly override options for a specific group by using an object with the `group` property and other option overrides.
+
+- `type` — Overrides the [`type`](#type) option for that group.
+
+```ts
+{
+  groups: [
+    'myCustomGroup1',
+    { group: 'myCustomGroup2', type: 'unsorted' }, // Elements from this group will not be sorted
+  ]
+}
+```
+
+#### Newlines between groups
+
+You may place `newlinesBetween` objects between your groups to enforce the newline behavior between two specific groups.
+
+See the [`newlinesBetween`](#newlinesbetween) option.
+
+This feature is only applicable when [`partitionByNewLine`](#partitionbynewline) is `false`.
+
+```ts
+{
+  newlinesBetween: 1,
+  groups: [
+    'a',
+    { newlinesBetween: 0 }, // Overrides the global newlinesBetween option
+    'b',
+  ]
+}
+```
+
 ### customGroups
 
 Define custom attribute groups with optional per-group sort overrides.