feat(sort-objects): add pattern matching for variable declarations

Author: hugop95

docs/content/rules/sort-objects.mdx

@@ -323,6 +323,7 @@ The `groups` attribute specifies whether to use groups to sort destructured obje
   {
     allNamesMatchPattern?: string | string[] | { pattern: string; flags: string } | { pattern: string; flags: string }[]
     callingFunctionNamePattern?: string | string[] | { pattern: string; flags: string } | { pattern: string; flags: string }[]
+    declarationMatchesPattern?: string | string[] | { pattern: string; flags: string } | { pattern: string; flags: string }[]
     declarationCommentMatchesPattern?: string | string[] | { pattern: string; flags: string } | { pattern: string; flags: string }[]
   }
   ```
@@ -387,6 +388,26 @@ Example configuration:
 }
 ```
 
+- `declarationMatchesPattern` — A regexp pattern that the object's declaration name must match.
+
+Example configuration:
+```ts
+{
+  'perfectionist/sort-objects': [
+    'error',
+    {
+      type: 'unsorted', // Do not sort metadata objects
+      useConfigurationIf: {
+        declarationMatchesPattern: '*metadata$',
+      },
+    },
+    {
+      type: 'alphabetical' // Fallback configuration
+    }
+  ],
+}
+```
+
 - `declarationCommentMatchesPattern` — A regexp pattern to specify which comments above the object declaration should match.
 
 Example configuration:

rules/sort-objects.ts

@@ -426,6 +426,7 @@ export default createEslintRule<Options, MessageId>({
             additionalProperties: {
               declarationCommentMatchesPattern: regexJsonSchema,
               callingFunctionNamePattern: regexJsonSchema,
+              declarationMatchesPattern: regexJsonSchema,
             },
           }),
           objectDeclarations: {
@@ -516,13 +517,32 @@ function computeMatchedContextOptions({
       if (!objectParent) {
         return false
       }
-      if (objectParent.type === 'VariableDeclarator' || !objectParent.name) {
+      if (objectParent.type !== 'CallExpression' || !objectParent.name) {
         return false
       }
-      return matches(
+      let patternMatches = matches(
         objectParent.name,
         options.useConfigurationIf.callingFunctionNamePattern,
       )
+      if (!patternMatches) {
+        return false
+      }
+    }
+
+    if (options.useConfigurationIf.declarationMatchesPattern) {
+      if (!objectParent) {
+        return false
+      }
+      if (objectParent.type !== 'VariableDeclarator' || !objectParent.name) {
+        return false
+      }
+      let patternMatches = matches(
+        objectParent.name,
+        options.useConfigurationIf.declarationMatchesPattern,
+      )
+      if (!patternMatches) {
+        return false
+      }
     }
 
     return true

rules/sort-objects/types.ts

@@ -42,6 +42,12 @@ export type Options = Partial<
        */
       callingFunctionNamePattern?: RegexOption
 
+      /**
+       * Regular expression pattern to match against the object's declaration
+       * name. The rule is only applied to declarations with matching names.
+       */
+      declarationMatchesPattern?: RegexOption
+
       /**
        * Regular expression pattern to match against all property names. The
        * rule is only applied when all property names match this pattern.

test/rules/sort-objects.test.ts

@@ -2318,6 +2318,135 @@ describe('sort-objects', () => {
       })
     })
 
+    it('applies configuration when declarationMatchesPattern matches', async () => {
+      await valid({
+        options: [
+          {
+            useConfigurationIf: {
+              declarationMatchesPattern: '^constant$',
+            },
+            type: 'unsorted',
+          },
+          options,
+        ],
+        code: dedent`
+          const constant = {
+            b,
+            a,
+            c,
+          }
+        `,
+      })
+
+      await valid({
+        options: [
+          {
+            useConfigurationIf: {
+              declarationMatchesPattern: '^constant$',
+            },
+            type: 'unsorted',
+          },
+          options,
+        ],
+        code: dedent`
+          const notAConstant = {
+            constant: {
+              b,
+              a,
+              c,
+            }
+          }
+        `,
+      })
+
+      await invalid({
+        options: [
+          {
+            ...options,
+            useConfigurationIf: {
+              declarationMatchesPattern: '^.*$',
+            },
+            type: 'unsorted',
+          },
+        ],
+        errors: [
+          {
+            data: {
+              right: 'a',
+              left: 'b',
+            },
+            messageId: 'unexpectedObjectsOrder',
+          },
+        ],
+        output: dedent`
+          func({ a: 1, b: 1 })
+        `,
+        code: dedent`
+          func({ b: 1, a: 1 })
+        `,
+      })
+
+      await invalid({
+        options: [
+          {
+            useConfigurationIf: {
+              declarationMatchesPattern: '^constant$',
+            },
+            type: 'unsorted',
+          },
+          options,
+        ],
+        errors: [
+          {
+            data: {
+              right: 'a',
+              left: 'b',
+            },
+            messageId: 'unexpectedObjectsOrder',
+          },
+        ],
+        output: dedent`
+          let notAConstant = {
+            a,
+            b,
+          }
+        `,
+        code: dedent`
+          let notAConstant = {
+            b,
+            a,
+          }
+        `,
+      })
+
+      await invalid({
+        options: [
+          {
+            ...options,
+            useConfigurationIf: {
+              declarationMatchesPattern: '^.*$',
+            },
+            type: 'unsorted',
+          },
+        ],
+        errors: [
+          {
+            data: {
+              right: 'a',
+              left: 'b',
+            },
+            messageId: 'unexpectedObjectsOrder',
+          },
+        ],
+        output: dedent`
+          ({ a: 1, b: 1 })
+        `,
+        code: dedent`
+          ({ b: 1, a: 1 })
+        `,
+      })
+    })
+
     it('applies configuration when declaration comment matches', async () => {
       await valid({
         options: [