eslint-plugin-perfectionist 3.3.0 → 3.4.0

package/dist/rules/sort-enums.mjs

@@ -1,3 +1,4 @@
+import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.mjs'
 import { isPartitionComment } from '../utils/is-partition-comment.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getCommentBefore } from '../utils/get-comment-before.mjs'
@@ -5,12 +6,10 @@ import { getSourceCode } from '../utils/get-source-code.mjs'
 import { toSingleLine } from '../utils/to-single-line.mjs'
 import { rangeToDiff } from '../utils/range-to-diff.mjs'
 import { getSettings } from '../utils/get-settings.mjs'
-import { isPositive } from '../utils/is-positive.mjs'
 import { sortNodes } from '../utils/sort-nodes.mjs'
 import { makeFixes } from '../utils/make-fixes.mjs'
 import { complete } from '../utils/complete.mjs'
 import { pairwise } from '../utils/pairwise.mjs'
-import { compare } from '../utils/compare.mjs'
 const sortEnums = createEslintRule({
   name: 'sort-enums',
   meta: {
@@ -149,7 +148,7 @@ const sortEnums = createEslintRule({
               member.id.type === 'Literal'
                 ? `${member.id.value}`
                 : `${sourceCode.text.slice(...member.id.range)}`
-            let dependencies
+            let dependencies = []
             if (member.initializer) {
               dependencies = extractDependencies(
                 member.initializer,
@@ -204,8 +203,13 @@ const sortEnums = createEslintRule({
               : void 0,
         }
         for (let nodes of formattedMembers) {
+          let sortedNodes = sortNodesByDependencies(
+            sortNodes(nodes, compareOptions),
+          )
           pairwise(nodes, (left, right) => {
-            if (isPositive(compare(left, right, compareOptions))) {
+            let indexOfLeft = sortedNodes.indexOf(left)
+            let indexOfRight = sortedNodes.indexOf(right)
+            if (indexOfLeft > indexOfRight) {
               context.report({
                 messageId: 'unexpectedEnumsOrder',
                 data: {
@@ -214,13 +218,9 @@ const sortEnums = createEslintRule({
                 },
                 node: right.node,
                 fix: fixer =>
-                  makeFixes(
-                    fixer,
-                    nodes,
-                    sortNodes(nodes, compareOptions),
-                    sourceCode,
-                    { partitionComment },
-                  ),
+                  makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                    partitionComment,
+                  }),
               })
             }
           })

package/dist/rules/sort-imports.js

@@ -1,6 +1,7 @@
 'use strict'
 const node_module = require('node:module')
 const minimatch = require('minimatch')
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const getCommentBefore = require('../utils/get-comment-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getLinesBetween = require('../utils/get-lines-between.js')
@@ -202,6 +203,33 @@ const sortImports = createEslintRule.createEslintRule({
     if (!hasUnknownGroup) {
       options.groups = [...options.groups, 'unknown']
     }
+    validateGroupsConfiguration.validateGroupsConfiguration(
+      options.groups,
+      [
+        'side-effect-style',
+        'external-type',
+        'internal-type',
+        'builtin-type',
+        'sibling-type',
+        'parent-type',
+        'side-effect',
+        'index-type',
+        'internal',
+        'external',
+        'sibling',
+        'unknown',
+        'builtin',
+        'parent',
+        'object',
+        'index',
+        'style',
+        'type',
+      ],
+      [
+        ...Object.keys(options.customGroups.type ?? {}),
+        ...Object.keys(options.customGroups.value ?? {}),
+      ],
+    )
     let nodes = []
     let isSideEffectImport = node =>
       node.type === 'ImportDeclaration' &&

package/dist/rules/sort-imports.mjs

@@ -1,5 +1,6 @@
 import { builtinModules } from 'node:module'
 import { minimatch } from 'minimatch'
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
 import { getCommentBefore } from '../utils/get-comment-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getLinesBetween } from '../utils/get-lines-between.mjs'
@@ -201,6 +202,33 @@ const sortImports = createEslintRule({
     if (!hasUnknownGroup) {
       options.groups = [...options.groups, 'unknown']
     }
+    validateGroupsConfiguration(
+      options.groups,
+      [
+        'side-effect-style',
+        'external-type',
+        'internal-type',
+        'builtin-type',
+        'sibling-type',
+        'parent-type',
+        'side-effect',
+        'index-type',
+        'internal',
+        'external',
+        'sibling',
+        'unknown',
+        'builtin',
+        'parent',
+        'object',
+        'index',
+        'style',
+        'type',
+      ],
+      [
+        ...Object.keys(options.customGroups.type ?? {}),
+        ...Object.keys(options.customGroups.value ?? {}),
+      ],
+    )
     let nodes = []
     let isSideEffectImport = node =>
       node.type === 'ImportDeclaration' &&

package/dist/rules/sort-interfaces.js

@@ -1,5 +1,6 @@
 'use strict'
 const minimatch = require('minimatch')
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const isMemberOptional = require('../utils/is-member-optional.js')
 const getLinesBetween = require('../utils/get-lines-between.js')
@@ -130,6 +131,11 @@ const sortInterfaces = createEslintRule.createEslintRule({
           order: 'asc',
           groups: [],
         })
+        validateGroupsConfiguration.validateGroupsConfiguration(
+          options.groups,
+          ['multiline', 'unknown'],
+          Object.keys(options.customGroups),
+        )
         let sourceCode = getSourceCode.getSourceCode(context)
         if (
           !options.ignorePattern.some(pattern =>

package/dist/rules/sort-interfaces.mjs

@@ -1,4 +1,5 @@
 import { minimatch } from 'minimatch'
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { isMemberOptional } from '../utils/is-member-optional.mjs'
 import { getLinesBetween } from '../utils/get-lines-between.mjs'
@@ -129,6 +130,11 @@ const sortInterfaces = createEslintRule({
           order: 'asc',
           groups: [],
         })
+        validateGroupsConfiguration(
+          options.groups,
+          ['multiline', 'unknown'],
+          Object.keys(options.customGroups),
+        )
         let sourceCode = getSourceCode(context)
         if (
           !options.ignorePattern.some(pattern =>

package/dist/rules/sort-intersection-types.js

@@ -1,4 +1,5 @@
 'use strict'
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -83,6 +84,25 @@ const sortIntersectionTypes = createEslintRule.createEslintRule({
         order: 'asc',
         groups: [],
       })
+      validateGroupsConfiguration.validateGroupsConfiguration(
+        options.groups,
+        [
+          'intersection',
+          'conditional',
+          'function',
+          'operator',
+          'keyword',
+          'literal',
+          'nullish',
+          'unknown',
+          'import',
+          'object',
+          'named',
+          'tuple',
+          'union',
+        ],
+        [],
+      )
       let sourceCode = getSourceCode.getSourceCode(context)
       let nodes = node.types.map(type => {
         let { getGroup, defineGroup } = useGroups.useGroups(options.groups)

package/dist/rules/sort-intersection-types.mjs

@@ -1,3 +1,4 @@
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
@@ -82,6 +83,25 @@ const sortIntersectionTypes = createEslintRule({
         order: 'asc',
         groups: [],
       })
+      validateGroupsConfiguration(
+        options.groups,
+        [
+          'intersection',
+          'conditional',
+          'function',
+          'operator',
+          'keyword',
+          'literal',
+          'nullish',
+          'unknown',
+          'import',
+          'object',
+          'named',
+          'tuple',
+          'union',
+        ],
+        [],
+      )
       let sourceCode = getSourceCode(context)
       let nodes = node.types.map(type => {
         let { getGroup, defineGroup } = useGroups(options.groups)

package/dist/rules/sort-jsx-props.js

@@ -1,5 +1,6 @@
 'use strict'
 const minimatch = require('minimatch')
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -113,6 +114,11 @@ const sortJsxProps = createEslintRule.createEslintRule({
           order: 'asc',
           groups: [],
         })
+        validateGroupsConfiguration.validateGroupsConfiguration(
+          options.groups,
+          ['multiline', 'shorthand', 'unknown'],
+          Object.keys(options.customGroups),
+        )
         let sourceCode = getSourceCode.getSourceCode(context)
         let shouldIgnore = false
         if (options.ignorePattern.length) {

package/dist/rules/sort-jsx-props.mjs

@@ -1,4 +1,5 @@
 import { minimatch } from 'minimatch'
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
@@ -112,6 +113,11 @@ const sortJsxProps = createEslintRule({
           order: 'asc',
           groups: [],
         })
+        validateGroupsConfiguration(
+          options.groups,
+          ['multiline', 'shorthand', 'unknown'],
+          Object.keys(options.customGroups),
+        )
         let sourceCode = getSourceCode(context)
         let shouldIgnore = false
         if (options.ignorePattern.length) {

package/dist/rules/sort-object-types.js

@@ -1,4 +1,5 @@
 'use strict'
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getLinesBetween = require('../utils/get-lines-between.js')
 const getGroupNumber = require('../utils/get-group-number.js')
@@ -118,6 +119,11 @@ const sortObjectTypes = createEslintRule.createEslintRule({
           order: 'asc',
           groups: [],
         })
+        validateGroupsConfiguration.validateGroupsConfiguration(
+          options.groups,
+          ['multiline', 'unknown'],
+          Object.keys(options.customGroups),
+        )
         let sourceCode = getSourceCode.getSourceCode(context)
         let formattedMembers = node.members.reduce(
           (accumulator, member) => {

package/dist/rules/sort-object-types.mjs

@@ -1,3 +1,4 @@
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getLinesBetween } from '../utils/get-lines-between.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
@@ -117,6 +118,11 @@ const sortObjectTypes = createEslintRule({
           order: 'asc',
           groups: [],
         })
+        validateGroupsConfiguration(
+          options.groups,
+          ['multiline', 'unknown'],
+          Object.keys(options.customGroups),
+        )
         let sourceCode = getSourceCode(context)
         let formattedMembers = node.members.reduce(
           (accumulator, member) => {

package/dist/rules/sort-objects.js

@@ -1,5 +1,7 @@
 'use strict'
 const minimatch = require('minimatch')
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
+const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
 const getCommentBefore = require('../utils/get-comment-before.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
@@ -10,13 +12,11 @@ const getNodeParent = require('../utils/get-node-parent.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
 const getSettings = require('../utils/get-settings.js')
-const isPositive = require('../utils/is-positive.js')
 const useGroups = require('../utils/use-groups.js')
 const makeFixes = require('../utils/make-fixes.js')
 const sortNodes = require('../utils/sort-nodes.js')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
-const compare = require('../utils/compare.js')
 const sortObjects = createEslintRule.createEslintRule({
   name: 'sort-objects',
   meta: {
@@ -155,6 +155,11 @@ const sortObjects = createEslintRule.createEslintRule({
         order: 'asc',
         groups: [],
       })
+      validateGroupsConfiguration.validateGroupsConfiguration(
+        options.groups,
+        ['unknown'],
+        Object.keys(options.customGroups),
+      )
       let shouldIgnore = false
       if (options.destructureOnly) {
         shouldIgnore = node.type !== 'ObjectPattern'
@@ -327,48 +332,34 @@ const sortObjects = createEslintRule.createEslintRule({
             [[]],
           )
         for (let nodes of formatProperties(node.properties)) {
+          let grouped = {}
+          for (let currentNode of nodes) {
+            let groupNum = getGroupNumber.getGroupNumber(
+              options.groups,
+              currentNode,
+            )
+            if (!(groupNum in grouped)) {
+              grouped[groupNum] = [currentNode]
+            } else {
+              grouped[groupNum].push(currentNode)
+            }
+          }
+          let sortedNodes = []
+          for (let group of Object.keys(grouped).sort(
+            (a, b) => Number(a) - Number(b),
+          )) {
+            sortedNodes.push(...sortNodes.sortNodes(grouped[group], options))
+          }
+          sortedNodes =
+            sortNodesByDependencies.sortNodesByDependencies(sortedNodes)
           pairwise.pairwise(nodes, (left, right) => {
-            let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
-            let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
-            if (
-              leftNum > rightNum ||
-              (leftNum === rightNum &&
-                isPositive.isPositive(compare.compare(left, right, options)))
-            ) {
-              let fix = fixer => {
-                let grouped = {}
-                for (let currentNode of nodes) {
-                  let groupNum = getGroupNumber.getGroupNumber(
-                    options.groups,
-                    currentNode,
-                  )
-                  if (!(groupNum in grouped)) {
-                    grouped[groupNum] = [currentNode]
-                  } else {
-                    grouped[groupNum] = sortNodes.sortNodes(
-                      [...grouped[groupNum], currentNode],
-                      options,
-                    )
-                  }
-                }
-                let sortedNodes = []
-                for (let group of Object.keys(grouped).sort(
-                  (a, b) => Number(a) - Number(b),
-                )) {
-                  sortedNodes.push(
-                    ...sortNodes.sortNodes(grouped[group], options),
-                  )
-                }
-                return makeFixes.makeFixes(
-                  fixer,
-                  nodes,
-                  sortedNodes,
-                  sourceCode,
-                  {
-                    partitionComment: options.partitionByComment,
-                  },
-                )
-              }
+            let indexOfLeft = sortedNodes.indexOf(left)
+            let indexOfRight = sortedNodes.indexOf(right)
+            if (indexOfLeft > indexOfRight) {
+              let fix = fixer =>
+                makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+                  partitionComment: options.partitionByComment,
+                })
               context.report({
                 messageId: 'unexpectedObjectsOrder',
                 data: {

package/dist/rules/sort-objects.mjs

@@ -1,4 +1,6 @@
 import { minimatch } from 'minimatch'
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
+import { sortNodesByDependencies } from '../utils/sort-nodes-by-dependencies.mjs'
 import { isPartitionComment } from '../utils/is-partition-comment.mjs'
 import { getCommentBefore } from '../utils/get-comment-before.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
@@ -9,13 +11,11 @@ import { getNodeParent } from '../utils/get-node-parent.mjs'
 import { toSingleLine } from '../utils/to-single-line.mjs'
 import { rangeToDiff } from '../utils/range-to-diff.mjs'
 import { getSettings } from '../utils/get-settings.mjs'
-import { isPositive } from '../utils/is-positive.mjs'
 import { useGroups } from '../utils/use-groups.mjs'
 import { makeFixes } from '../utils/make-fixes.mjs'
 import { sortNodes } from '../utils/sort-nodes.mjs'
 import { complete } from '../utils/complete.mjs'
 import { pairwise } from '../utils/pairwise.mjs'
-import { compare } from '../utils/compare.mjs'
 const sortObjects = createEslintRule({
   name: 'sort-objects',
   meta: {
@@ -154,6 +154,11 @@ const sortObjects = createEslintRule({
         order: 'asc',
         groups: [],
       })
+      validateGroupsConfiguration(
+        options.groups,
+        ['unknown'],
+        Object.keys(options.customGroups),
+      )
       let shouldIgnore = false
       if (options.destructureOnly) {
         shouldIgnore = node.type !== 'ObjectPattern'
@@ -314,37 +319,30 @@ const sortObjects = createEslintRule({
             [[]],
           )
         for (let nodes of formatProperties(node.properties)) {
+          let grouped = {}
+          for (let currentNode of nodes) {
+            let groupNum = getGroupNumber(options.groups, currentNode)
+            if (!(groupNum in grouped)) {
+              grouped[groupNum] = [currentNode]
+            } else {
+              grouped[groupNum].push(currentNode)
+            }
+          }
+          let sortedNodes = []
+          for (let group of Object.keys(grouped).sort(
+            (a, b) => Number(a) - Number(b),
+          )) {
+            sortedNodes.push(...sortNodes(grouped[group], options))
+          }
+          sortedNodes = sortNodesByDependencies(sortedNodes)
           pairwise(nodes, (left, right) => {
-            let leftNum = getGroupNumber(options.groups, left)
-            let rightNum = getGroupNumber(options.groups, right)
-            if (
-              leftNum > rightNum ||
-              (leftNum === rightNum &&
-                isPositive(compare(left, right, options)))
-            ) {
-              let fix = fixer => {
-                let grouped = {}
-                for (let currentNode of nodes) {
-                  let groupNum = getGroupNumber(options.groups, currentNode)
-                  if (!(groupNum in grouped)) {
-                    grouped[groupNum] = [currentNode]
-                  } else {
-                    grouped[groupNum] = sortNodes(
-                      [...grouped[groupNum], currentNode],
-                      options,
-                    )
-                  }
-                }
-                let sortedNodes = []
-                for (let group of Object.keys(grouped).sort(
-                  (a, b) => Number(a) - Number(b),
-                )) {
-                  sortedNodes.push(...sortNodes(grouped[group], options))
-                }
-                return makeFixes(fixer, nodes, sortedNodes, sourceCode, {
+            let indexOfLeft = sortedNodes.indexOf(left)
+            let indexOfRight = sortedNodes.indexOf(right)
+            if (indexOfLeft > indexOfRight) {
+              let fix = fixer =>
+                makeFixes(fixer, nodes, sortedNodes, sourceCode, {
                   partitionComment: options.partitionByComment,
                 })
-              }
               context.report({
                 messageId: 'unexpectedObjectsOrder',
                 data: {

package/dist/rules/sort-sets.js

@@ -0,0 +1,48 @@
+'use strict'
+const createEslintRule = require('../utils/create-eslint-rule.js')
+const sortArrayIncludes = require('./sort-array-includes.js')
+const sortSets = createEslintRule.createEslintRule({
+  name: 'sort-sets',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce sorted sets.',
+    },
+    fixable: 'code',
+    schema: [sortArrayIncludes.jsonSchema],
+    messages: {
+      unexpectedSetsOrder: 'Expected "{{right}}" to come before "{{left}}".',
+    },
+  },
+  defaultOptions: [
+    {
+      type: 'alphabetical',
+      order: 'asc',
+      ignoreCase: true,
+      groupKind: 'literals-first',
+    },
+  ],
+  create: context => ({
+    NewExpression: node => {
+      var _a, _b
+      if (
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'Set' &&
+        node.arguments.length &&
+        (((_a = node.arguments[0]) == null ? void 0 : _a.type) ===
+          'ArrayExpression' ||
+          (((_b = node.arguments[0]) == null ? void 0 : _b.type) ===
+            'NewExpression' &&
+            'name' in node.arguments[0].callee &&
+            node.arguments[0].callee.name === 'Array'))
+      ) {
+        let elements =
+          node.arguments[0].type === 'ArrayExpression'
+            ? node.arguments[0].elements
+            : node.arguments[0].arguments
+        sortArrayIncludes.sortArray(context, 'unexpectedSetsOrder', elements)
+      }
+    },
+  }),
+})
+module.exports = sortSets

package/dist/rules/sort-sets.mjs

@@ -0,0 +1,47 @@
+import { createEslintRule } from '../utils/create-eslint-rule.mjs'
+import { jsonSchema, sortArray } from './sort-array-includes.mjs'
+const sortSets = createEslintRule({
+  name: 'sort-sets',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce sorted sets.',
+    },
+    fixable: 'code',
+    schema: [jsonSchema],
+    messages: {
+      unexpectedSetsOrder: 'Expected "{{right}}" to come before "{{left}}".',
+    },
+  },
+  defaultOptions: [
+    {
+      type: 'alphabetical',
+      order: 'asc',
+      ignoreCase: true,
+      groupKind: 'literals-first',
+    },
+  ],
+  create: context => ({
+    NewExpression: node => {
+      var _a, _b
+      if (
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'Set' &&
+        node.arguments.length &&
+        (((_a = node.arguments[0]) == null ? void 0 : _a.type) ===
+          'ArrayExpression' ||
+          (((_b = node.arguments[0]) == null ? void 0 : _b.type) ===
+            'NewExpression' &&
+            'name' in node.arguments[0].callee &&
+            node.arguments[0].callee.name === 'Array'))
+      ) {
+        let elements =
+          node.arguments[0].type === 'ArrayExpression'
+            ? node.arguments[0].elements
+            : node.arguments[0].arguments
+        sortArray(context, 'unexpectedSetsOrder', elements)
+      }
+    },
+  }),
+})
+export { sortSets as default }

package/dist/rules/sort-svelte-attributes.js

@@ -1,5 +1,6 @@
 'use strict'
 const path = require('node:path')
+const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -107,6 +108,11 @@ const sortSvelteAttributes = createEslintRule.createEslintRule({
             order: 'asc',
             groups: [],
           })
+          validateGroupsConfiguration.validateGroupsConfiguration(
+            options.groups,
+            ['svelte-shorthand', 'multiline', 'shorthand', 'unknown'],
+            Object.keys(options.customGroups),
+          )
           let sourceCode = getSourceCode.getSourceCode(context)
           let parts = node.attributes.reduce(
             (accumulator, attribute) => {

package/dist/rules/sort-svelte-attributes.mjs

@@ -1,4 +1,5 @@
 import path from 'node:path'
+import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.mjs'
 import { createEslintRule } from '../utils/create-eslint-rule.mjs'
 import { getGroupNumber } from '../utils/get-group-number.mjs'
 import { getSourceCode } from '../utils/get-source-code.mjs'
@@ -106,6 +107,11 @@ const sortSvelteAttributes = createEslintRule({
             order: 'asc',
             groups: [],
           })
+          validateGroupsConfiguration(
+            options.groups,
+            ['svelte-shorthand', 'multiline', 'shorthand', 'unknown'],
+            Object.keys(options.customGroups),
+          )
           let sourceCode = getSourceCode(context)
           let parts = node.attributes.reduce(
             (accumulator, attribute) => {