eslint-plugin-perfectionist 3.3.0 → 3.4.0

package/dist/index.d.ts

@@ -3,6 +3,100 @@ import { FlatConfig } from '@typescript-eslint/utils/ts-eslint'
 import { RuleListener } from '@typescript-eslint/utils/ts-eslint'
 import { RuleModule } from '@typescript-eslint/utils/ts-eslint'
 
+declare type AbstractModifier = 'abstract'
+
+declare type AccessorPropertyGroup =
+  `${PublicOrProtectedOrPrivateModifierPrefix}${StaticOrAbstractModifierPrefix}${OverrideModifierPrefix}${DecoratedModifierPrefix}${AccessorPropertySelector}`
+
+declare type AccessorPropertySelector = 'accessor-property'
+
+declare type AdvancedSingleCustomGroup<T extends Selector> = {
+  decoratorNamePattern?: string
+  elementNamePattern?: string
+} & BaseSingleCustomGroup<T>
+
+/**
+ * Only used in code as well
+ */
+declare interface AllowedModifiersPerSelector {
+  property:
+    | PublicOrProtectedOrPrivateModifier
+    | DecoratedModifier
+    | AbstractModifier
+    | OverrideModifier
+    | ReadonlyModifier
+    | OptionalModifier
+    | DeclareModifier
+    | StaticModifier
+  method:
+    | PublicOrProtectedOrPrivateModifier
+    | DecoratedModifier
+    | AbstractModifier
+    | OverrideModifier
+    | OptionalModifier
+    | StaticModifier
+  'accessor-property':
+    | PublicOrProtectedOrPrivateModifier
+    | DecoratedModifier
+    | AbstractModifier
+    | OverrideModifier
+    | StaticModifier
+  'function-property':
+    | PublicOrProtectedOrPrivateModifier
+    | DecoratedModifier
+    | OverrideModifier
+    | ReadonlyModifier
+    | StaticModifier
+  'set-method':
+    | PublicOrProtectedOrPrivateModifier
+    | DecoratedModifier
+    | AbstractModifier
+    | OverrideModifier
+    | StaticModifier
+  'get-method': AllowedModifiersPerSelector['set-method']
+  'index-signature': ReadonlyModifier | StaticModifier
+  constructor: PublicOrProtectedOrPrivateModifier
+  'static-block': never
+}
+
+declare interface BaseSingleCustomGroup<T extends Selector> {
+  modifiers?: AllowedModifiersPerSelector[T][]
+  selector?: T
+}
+
+declare type ConstructorGroup =
+  `${PublicOrProtectedOrPrivateModifierPrefix}${ConstructorSelector}`
+
+declare type ConstructorSelector = 'constructor'
+
+declare type CustomGroup = (
+  | {
+      order?: SortClassesOptions[0]['order']
+      type?: SortClassesOptions[0]['type']
+    }
+  | {
+      type?: 'unsorted'
+    }
+) &
+  (SingleCustomGroup | CustomGroupBlock) & {
+    groupName: string
+  }
+
+declare interface CustomGroupBlock {
+  anyOf: SingleCustomGroup[]
+}
+
+declare type DeclareModifier = 'declare'
+
+declare type DeclareModifierPrefix = WithDashSuffixOrEmpty<DeclareModifier>
+
+declare type DeclarePropertyGroup =
+  `${DeclareModifierPrefix}${PublicOrProtectedOrPrivateModifierPrefix}${StaticOrAbstractModifierPrefix}${ReadonlyModifierPrefix}${OptionalModifierPrefix}${PropertySelector}`
+
+declare type DecoratedModifier = 'decorated'
+
+declare type DecoratedModifierPrefix = WithDashSuffixOrEmpty<DecoratedModifier>
+
 declare const _default: {
   configs: {
     'recommended-alphabetical-legacy': ClassicConfig.Config
@@ -119,14 +213,7 @@ declare const _default: {
     >
     'sort-array-includes': RuleModule<
       'unexpectedArrayIncludesOrder',
-      [
-        Partial<{
-          groupKind: 'literals-first' | 'spreads-first' | 'mixed'
-          type: 'alphabetical' | 'line-length' | 'natural'
-          order: 'desc' | 'asc'
-          ignoreCase: boolean
-        }>,
-      ],
+      Options,
       unknown,
       RuleListener
     >
@@ -162,12 +249,14 @@ declare const _default: {
       [
         Partial<{
           groupKind: 'required-first' | 'optional-first' | 'mixed'
+          customGroups: {
+            [x: string]: string | string[]
+          }
           type: 'alphabetical' | 'line-length' | 'natural'
           groups: (string | string[])[]
           partitionByNewLine: boolean
           order: 'desc' | 'asc'
           ignoreCase: boolean
-          customGroups: {}
         }>,
       ],
       unknown,
@@ -267,18 +356,7 @@ declare const _default: {
     >
     'sort-classes': RuleModule<
       'unexpectedClassesGroupOrder' | 'unexpectedClassesOrder',
-      [
-        Partial<{
-          customGroups: {
-            [key: string]: string[] | string
-          }
-          type: 'alphabetical' | 'line-length' | 'natural'
-          partitionByComment: string[] | boolean | string
-          groups: (string[] | string)[]
-          order: 'desc' | 'asc'
-          ignoreCase: boolean
-        }>,
-      ],
+      SortClassesOptions,
       unknown,
       RuleListener
     >
@@ -348,6 +426,12 @@ declare const _default: {
     >
     'sort-enums': RuleModule<
       'unexpectedEnumsOrder',
+      Options_2,
+      unknown,
+      RuleListener
+    >
+    'sort-sets': RuleModule<
+      'unexpectedSetsOrder',
       Options,
       unknown,
       RuleListener
@@ -368,7 +452,66 @@ declare const _default: {
   name: string
 }
 
+declare type FunctionPropertyGroup =
+  `${PublicOrProtectedOrPrivateModifierPrefix}${StaticModifierPrefix}${OverrideModifierPrefix}${ReadonlyModifierPrefix}${DecoratedModifierPrefix}${FunctionPropertySelector}`
+
+declare type FunctionPropertySelector = 'function-property'
+
+declare type GetMethodOrSetMethodGroup =
+  `${PublicOrProtectedOrPrivateModifierPrefix}${StaticOrAbstractModifierPrefix}${OverrideModifierPrefix}${DecoratedModifierPrefix}${GetMethodOrSetMethodSelector}`
+
+declare type GetMethodOrSetMethodSelector =
+  | GetMethodSelector
+  | SetMethodSelector
+
+declare type GetMethodSelector = 'get-method'
+
+/**
+ * Some invalid combinations are still handled by this type, such as
+ * - private abstract X
+ * - abstract decorated X
+ * Only used in code, so I don't know if it's worth maintaining this.
+ */
+declare type Group =
+  | GetMethodOrSetMethodGroup
+  | NonDeclarePropertyGroup
+  | AccessorPropertyGroup
+  | FunctionPropertyGroup
+  | DeclarePropertyGroup
+  | IndexSignatureGroup
+  | ConstructorGroup
+  | StaticBlockGroup
+  | MethodGroup
+  | 'unknown'
+  | string
+
+declare type IndexSignatureGroup =
+  `${StaticModifierPrefix}${ReadonlyModifierPrefix}${IndexSignatureSelector}`
+
+declare type IndexSignatureSelector = 'index-signature'
+
+declare type MethodGroup =
+  `${PublicOrProtectedOrPrivateModifierPrefix}${StaticOrAbstractModifierPrefix}${OverrideModifierPrefix}${DecoratedModifierPrefix}${OptionalModifierPrefix}${MethodSelector}`
+
+declare type MethodSelector = 'method'
+
+declare type NonDeclarePropertyGroup =
+  `${PublicOrProtectedOrPrivateModifierPrefix}${StaticOrAbstractModifierPrefix}${OverrideModifierPrefix}${ReadonlyModifierPrefix}${DecoratedModifierPrefix}${OptionalModifierPrefix}${PropertySelector}`
+
+declare type OptionalModifier = 'optional'
+
+declare type OptionalModifierPrefix = WithDashSuffixOrEmpty<OptionalModifier>
+
 declare type Options = [
+  Partial<{
+    groupKind: 'literals-first' | 'spreads-first' | 'mixed'
+    type: 'alphabetical' | 'line-length' | 'natural'
+    order: 'desc' | 'asc'
+    ignoreCase: boolean
+  }>,
+]
+
+declare type Options_2 = [
   Partial<{
     type: 'alphabetical' | 'line-length' | 'natural'
     partitionByComment: string[] | boolean | string
@@ -379,5 +522,83 @@ declare type Options = [
   }>,
 ]
 
+declare type OverrideModifier = 'override'
+
+declare type OverrideModifierPrefix = WithDashSuffixOrEmpty<OverrideModifier>
+
+declare type PrivateModifier = 'private'
+
+declare type PropertySelector = 'property'
+
+declare type ProtectedModifier = 'protected'
+
+declare type PublicModifier = 'public'
+
+declare type PublicOrProtectedOrPrivateModifier =
+  | ProtectedModifier
+  | PrivateModifier
+  | PublicModifier
+
+declare type PublicOrProtectedOrPrivateModifierPrefix = WithDashSuffixOrEmpty<
+  ProtectedModifier | PrivateModifier | PublicModifier
+>
+
+declare type ReadonlyModifier = 'readonly'
+
+declare type ReadonlyModifierPrefix = WithDashSuffixOrEmpty<ReadonlyModifier>
+
+declare type Selector =
+  | AccessorPropertySelector
+  | FunctionPropertySelector
+  | IndexSignatureSelector
+  | ConstructorSelector
+  | StaticBlockSelector
+  | GetMethodSelector
+  | SetMethodSelector
+  | PropertySelector
+  | MethodSelector
+
+declare type SetMethodSelector = 'set-method'
+
+declare type SingleCustomGroup =
+  | AdvancedSingleCustomGroup<FunctionPropertySelector>
+  | AdvancedSingleCustomGroup<AccessorPropertySelector>
+  | BaseSingleCustomGroup<IndexSignatureSelector>
+  | AdvancedSingleCustomGroup<GetMethodSelector>
+  | AdvancedSingleCustomGroup<SetMethodSelector>
+  | AdvancedSingleCustomGroup<PropertySelector>
+  | BaseSingleCustomGroup<StaticBlockSelector>
+  | BaseSingleCustomGroup<ConstructorSelector>
+  | AdvancedSingleCustomGroup<MethodSelector>
+
+declare type SortClassesOptions = [
+  Partial<{
+    customGroups:
+      | {
+          [key: string]: string[] | string
+        }
+      | CustomGroup[]
+    type: 'alphabetical' | 'line-length' | 'natural'
+    partitionByComment: string[] | boolean | string
+    groups: (Group[] | Group)[]
+    order: 'desc' | 'asc'
+    ignoreCase: boolean
+  }>,
+]
+
+declare type StaticBlockGroup = `${StaticBlockSelector}`
+
+declare type StaticBlockSelector = 'static-block'
+
+declare type StaticModifier = 'static'
+
+declare type StaticModifierPrefix = WithDashSuffixOrEmpty<StaticModifier>
+
+declare type StaticOrAbstractModifierPrefix = WithDashSuffixOrEmpty<
+  AbstractModifier | StaticModifier
+>
+
+declare type WithDashSuffixOrEmpty<T extends string> = `${T}-` | ''
+
 export {}
 export = _default

package/dist/index.js

@@ -18,6 +18,7 @@ const sortExports = require('./rules/sort-exports.js')
 const sortObjects = require('./rules/sort-objects.js')
 const sortEnums = require('./rules/sort-enums.js')
 const sortMaps = require('./rules/sort-maps.js')
+const sortSets = require('./rules/sort-sets.js')
 let name = 'perfectionist'
 let plugin = {
   rules: {
@@ -26,7 +27,7 @@ let plugin = {
     'sort-svelte-attributes': sortSvelteAttributes,
     'sort-astro-attributes': sortAstroAttributes,
     'sort-vue-attributes': sortVueAttributes,
-    'sort-array-includes': sortArrayIncludes,
+    'sort-array-includes': sortArrayIncludes.default,
     'sort-named-imports': sortNamedImports,
     'sort-named-exports': sortNamedExports,
     'sort-object-types': sortObjectTypes,
@@ -39,6 +40,7 @@ let plugin = {
     'sort-exports': sortExports,
     'sort-objects': sortObjects,
     'sort-enums': sortEnums,
+    'sort-sets': sortSets,
     'sort-maps': sortMaps,
   },
   name,

package/dist/index.mjs

@@ -17,6 +17,7 @@ import sortExports from './rules/sort-exports.mjs'
 import sortObjects from './rules/sort-objects.mjs'
 import sortEnums from './rules/sort-enums.mjs'
 import sortMaps from './rules/sort-maps.mjs'
+import sortSets from './rules/sort-sets.mjs'
 let name = 'perfectionist'
 let plugin = {
   rules: {
@@ -38,6 +39,7 @@ let plugin = {
     'sort-exports': sortExports,
     'sort-objects': sortObjects,
     'sort-enums': sortEnums,
+    'sort-sets': sortSets,
     'sort-maps': sortMaps,
   },
   name,

package/dist/rules/sort-array-includes.js

@@ -1,4 +1,8 @@
 'use strict'
+Object.defineProperties(exports, {
+  __esModule: { value: true },
+  [Symbol.toStringTag]: { value: 'Module' },
+})
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -11,6 +15,32 @@ const makeFixes = require('../utils/make-fixes.js')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
 const compare = require('../utils/compare.js')
+let jsonSchema = {
+  type: 'object',
+  properties: {
+    type: {
+      description: 'Specifies the sorting method.',
+      type: 'string',
+      enum: ['alphabetical', 'natural', 'line-length'],
+    },
+    order: {
+      description:
+        'Determines whether the sorted items should be in ascending or descending order.',
+      type: 'string',
+      enum: ['asc', 'desc'],
+    },
+    ignoreCase: {
+      description: 'Controls whether sorting should be case-sensitive or not.',
+      type: 'boolean',
+    },
+    groupKind: {
+      description: 'Specifies top-level groups.',
+      enum: ['mixed', 'literals-first', 'spreads-first'],
+      type: 'string',
+    },
+  },
+  additionalProperties: false,
+}
 const sortArrayIncludes = createEslintRule.createEslintRule({
   name: 'sort-array-includes',
   meta: {
@@ -19,35 +49,7 @@ const sortArrayIncludes = createEslintRule.createEslintRule({
       description: 'Enforce sorted arrays before include method.',
     },
     fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          type: {
-            description: 'Specifies the sorting method.',
-            type: 'string',
-            enum: ['alphabetical', 'natural', 'line-length'],
-          },
-          order: {
-            description:
-              'Determines whether the sorted items should be in ascending or descending order.',
-            type: 'string',
-            enum: ['asc', 'desc'],
-          },
-          ignoreCase: {
-            description:
-              'Controls whether sorting should be case-sensitive or not.',
-            type: 'boolean',
-          },
-          groupKind: {
-            description: 'Specifies top-level groups.',
-            enum: ['mixed', 'literals-first', 'spreads-first'],
-            type: 'string',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
+    schema: [jsonSchema],
     messages: {
       unexpectedArrayIncludesOrder:
         'Expected "{{right}}" to come before "{{left}}".',
@@ -73,85 +75,84 @@ const sortArrayIncludes = createEslintRule.createEslintRule({
           node.object.type === 'ArrayExpression'
             ? node.object.elements
             : node.object.arguments
-        let settings = getSettings.getSettings(context.settings)
-        if (elements.length > 1) {
-          let options = complete.complete(context.options.at(0), settings, {
-            groupKind: 'literals-first',
-            type: 'alphabetical',
-            ignoreCase: true,
-            order: 'asc',
-          })
-          let sourceCode = getSourceCode.getSourceCode(context)
-          let nodes = elements
-            .reduce(
-              (accumulator, element) => {
-                if (element !== null) {
-                  let group = 'unknown'
-                  if (typeof options.groupKind === 'string') {
-                    group =
-                      element.type === 'SpreadElement' ? 'spread' : 'literal'
-                  }
-                  accumulator.at(0).push({
-                    name:
-                      element.type === 'Literal'
-                        ? `${element.value}`
-                        : sourceCode.text.slice(...element.range),
-                    size: rangeToDiff.rangeToDiff(element.range),
-                    type: element.type,
-                    node: element,
-                    group,
-                  })
-                }
-                return accumulator
-              },
-              [[], []],
-            )
-            .flat()
-          pairwise.pairwise(nodes, (left, right) => {
-            let groupKindOrder = ['unknown']
-            if (typeof options.groupKind === 'string') {
-              groupKindOrder =
-                options.groupKind === 'literals-first'
-                  ? ['literal', 'spread']
-                  : ['spread', 'literal']
-            }
-            let leftNum = getGroupNumber.getGroupNumber(groupKindOrder, left)
-            let rightNum = getGroupNumber.getGroupNumber(groupKindOrder, right)
-            if (
-              (options.groupKind !== 'mixed' && leftNum > rightNum) ||
-              ((options.groupKind === 'mixed' || leftNum === rightNum) &&
-                isPositive.isPositive(compare.compare(left, right, options)))
-            ) {
-              context.report({
-                messageId: 'unexpectedArrayIncludesOrder',
-                data: {
-                  left: toSingleLine.toSingleLine(left.name),
-                  right: toSingleLine.toSingleLine(right.name),
-                },
-                node: right.node,
-                fix: fixer => {
-                  let sortedNodes =
-                    options.groupKind !== 'mixed'
-                      ? groupKindOrder
-                          .map(group => nodes.filter(n => n.group === group))
-                          .map(groupedNodes =>
-                            sortNodes.sortNodes(groupedNodes, options),
-                          )
-                          .flat()
-                      : sortNodes.sortNodes(nodes, options)
-                  return makeFixes.makeFixes(
-                    fixer,
-                    nodes,
-                    sortedNodes,
-                    sourceCode,
-                  )
-                },
-              })
-            }
-          })
-        }
+        sortArray(context, 'unexpectedArrayIncludesOrder', elements)
       }
     },
   }),
 })
-module.exports = sortArrayIncludes
+let sortArray = (context, messageId, elements) => {
+  let settings = getSettings.getSettings(context.settings)
+  if (elements.length > 1) {
+    let options = complete.complete(context.options.at(0), settings, {
+      groupKind: 'literals-first',
+      type: 'alphabetical',
+      ignoreCase: true,
+      order: 'asc',
+    })
+    let sourceCode = getSourceCode.getSourceCode(context)
+    let nodes = elements
+      .reduce(
+        (accumulator, element) => {
+          if (element !== null) {
+            let group = 'unknown'
+            if (typeof options.groupKind === 'string') {
+              group = element.type === 'SpreadElement' ? 'spread' : 'literal'
+            }
+            accumulator.at(0).push({
+              name:
+                element.type === 'Literal'
+                  ? `${element.value}`
+                  : sourceCode.text.slice(...element.range),
+              size: rangeToDiff.rangeToDiff(element.range),
+              type: element.type,
+              node: element,
+              group,
+            })
+          }
+          return accumulator
+        },
+        [[], []],
+      )
+      .flat()
+    pairwise.pairwise(nodes, (left, right) => {
+      let groupKindOrder = ['unknown']
+      if (typeof options.groupKind === 'string') {
+        groupKindOrder =
+          options.groupKind === 'literals-first'
+            ? ['literal', 'spread']
+            : ['spread', 'literal']
+      }
+      let leftNum = getGroupNumber.getGroupNumber(groupKindOrder, left)
+      let rightNum = getGroupNumber.getGroupNumber(groupKindOrder, right)
+      if (
+        (options.groupKind !== 'mixed' && leftNum > rightNum) ||
+        ((options.groupKind === 'mixed' || leftNum === rightNum) &&
+          isPositive.isPositive(compare.compare(left, right, options)))
+      ) {
+        context.report({
+          messageId,
+          data: {
+            left: toSingleLine.toSingleLine(left.name),
+            right: toSingleLine.toSingleLine(right.name),
+          },
+          node: right.node,
+          fix: fixer => {
+            let sortedNodes =
+              options.groupKind !== 'mixed'
+                ? groupKindOrder
+                    .map(group => nodes.filter(n => n.group === group))
+                    .map(groupedNodes =>
+                      sortNodes.sortNodes(groupedNodes, options),
+                    )
+                    .flat()
+                : sortNodes.sortNodes(nodes, options)
+            return makeFixes.makeFixes(fixer, nodes, sortedNodes, sourceCode)
+          },
+        })
+      }
+    })
+  }
+}
+exports.default = sortArrayIncludes
+exports.jsonSchema = jsonSchema
+exports.sortArray = sortArray