eslint-plugin-perfectionist 3.2.0 → 3.4.0

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

@@ -10,6 +10,32 @@ 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'
+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({
   name: 'sort-array-includes',
   meta: {
@@ -18,35 +44,7 @@ const sortArrayIncludes = 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}}".',
@@ -72,78 +70,80 @@ const sortArrayIncludes = createEslintRule({
           node.object.type === 'ArrayExpression'
             ? node.object.elements
             : node.object.arguments
-        let settings = getSettings(context.settings)
-        if (elements.length > 1) {
-          let options = complete(context.options.at(0), settings, {
-            groupKind: 'literals-first',
-            type: 'alphabetical',
-            ignoreCase: true,
-            order: 'asc',
-          })
-          let sourceCode = 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(element.range),
-                    type: element.type,
-                    node: element,
-                    group,
-                  })
-                }
-                return accumulator
-              },
-              [[], []],
-            )
-            .flat()
-          pairwise(nodes, (left, right) => {
-            let groupKindOrder = ['unknown']
-            if (typeof options.groupKind === 'string') {
-              groupKindOrder =
-                options.groupKind === 'literals-first'
-                  ? ['literal', 'spread']
-                  : ['spread', 'literal']
-            }
-            let leftNum = getGroupNumber(groupKindOrder, left)
-            let rightNum = getGroupNumber(groupKindOrder, right)
-            if (
-              (options.groupKind !== 'mixed' && leftNum > rightNum) ||
-              ((options.groupKind === 'mixed' || leftNum === rightNum) &&
-                isPositive(compare(left, right, options)))
-            ) {
-              context.report({
-                messageId: 'unexpectedArrayIncludesOrder',
-                data: {
-                  left: toSingleLine(left.name),
-                  right: 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(groupedNodes, options))
-                          .flat()
-                      : sortNodes(nodes, options)
-                  return makeFixes(fixer, nodes, sortedNodes, sourceCode)
-                },
-              })
-            }
-          })
-        }
+        sortArray(context, 'unexpectedArrayIncludesOrder', elements)
       }
     },
   }),
 })
-export { sortArrayIncludes as default }
+let sortArray = (context, messageId, elements) => {
+  let settings = getSettings(context.settings)
+  if (elements.length > 1) {
+    let options = complete(context.options.at(0), settings, {
+      groupKind: 'literals-first',
+      type: 'alphabetical',
+      ignoreCase: true,
+      order: 'asc',
+    })
+    let sourceCode = 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(element.range),
+              type: element.type,
+              node: element,
+              group,
+            })
+          }
+          return accumulator
+        },
+        [[], []],
+      )
+      .flat()
+    pairwise(nodes, (left, right) => {
+      let groupKindOrder = ['unknown']
+      if (typeof options.groupKind === 'string') {
+        groupKindOrder =
+          options.groupKind === 'literals-first'
+            ? ['literal', 'spread']
+            : ['spread', 'literal']
+      }
+      let leftNum = getGroupNumber(groupKindOrder, left)
+      let rightNum = getGroupNumber(groupKindOrder, right)
+      if (
+        (options.groupKind !== 'mixed' && leftNum > rightNum) ||
+        ((options.groupKind === 'mixed' || leftNum === rightNum) &&
+          isPositive(compare(left, right, options)))
+      ) {
+        context.report({
+          messageId,
+          data: {
+            left: toSingleLine(left.name),
+            right: 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(groupedNodes, options))
+                    .flat()
+                : sortNodes(nodes, options)
+            return makeFixes(fixer, nodes, sortedNodes, sourceCode)
+          },
+        })
+      }
+    })
+  }
+}
+export { sortArrayIncludes as default, jsonSchema, sortArray }

package/dist/rules/sort-astro-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')
@@ -109,6 +110,11 @@ const sortAstroAttributes = createEslintRule.createEslintRule({
             order: 'asc',
             groups: [],
           })
+          validateGroupsConfiguration.validateGroupsConfiguration(
+            options.groups,
+            ['astro-shorthand', 'multiline', 'shorthand', 'unknown'],
+            Object.keys(options.customGroups),
+          )
           let sourceCode = getSourceCode.getSourceCode(context)
           let parts = attributes.reduce(
             (accumulator, attribute) => {

package/dist/rules/sort-astro-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'
@@ -108,6 +109,11 @@ const sortAstroAttributes = createEslintRule({
             order: 'asc',
             groups: [],
           })
+          validateGroupsConfiguration(
+            options.groups,
+            ['astro-shorthand', 'multiline', 'shorthand', 'unknown'],
+            Object.keys(options.customGroups),
+          )
           let sourceCode = getSourceCode(context)
           let parts = attributes.reduce(
             (accumulator, attribute) => {

package/dist/rules/sort-classes-utils.js

@@ -1,5 +1,6 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const minimatch = require('minimatch')
 const cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 const generateOfficialGroups = (modifiers, selectors) => {
   let modifiersAndSelectorsKey = modifiers.join('&') + '/' + selectors.join('&')
@@ -65,4 +66,105 @@ const getPermutations = elements => {
   backtrack(0)
   return result
 }
+const getOverloadSignatureGroups = members => {
+  let methods = members
+    .filter(
+      member =>
+        member.type === 'MethodDefinition' ||
+        member.type === 'TSAbstractMethodDefinition',
+    )
+    .filter(member => member.kind === 'method')
+  let staticOverloadSignaturesByName = /* @__PURE__ */ new Map()
+  let overloadSignaturesByName = /* @__PURE__ */ new Map()
+  for (let method of methods) {
+    if (method.key.type !== 'Identifier') {
+      continue
+    }
+    let { name } = method.key
+    let mapToUse = method.static
+      ? staticOverloadSignaturesByName
+      : overloadSignaturesByName
+    let signatureOverloadsGroup = mapToUse.get(name)
+    if (!signatureOverloadsGroup) {
+      signatureOverloadsGroup = []
+      mapToUse.set(name, signatureOverloadsGroup)
+    }
+    signatureOverloadsGroup.push(method)
+  }
+  return [
+    ...overloadSignaturesByName.values(),
+    ...staticOverloadSignaturesByName.values(),
+  ].filter(group => group.length > 1)
+}
+const customGroupMatches = props => {
+  if ('anyOf' in props.customGroup) {
+    return props.customGroup.anyOf.some(subgroup =>
+      customGroupMatches({ ...props, customGroup: subgroup }),
+    )
+  }
+  if (
+    props.customGroup.selector &&
+    !props.selectors.includes(props.customGroup.selector)
+  ) {
+    return false
+  }
+  if (props.customGroup.modifiers) {
+    for (let modifier of props.customGroup.modifiers) {
+      if (!props.modifiers.includes(modifier)) {
+        return false
+      }
+    }
+  }
+  if (
+    'elementNamePattern' in props.customGroup &&
+    props.customGroup.elementNamePattern
+  ) {
+    let matchesElementNamePattern = minimatch.minimatch(
+      props.elementName,
+      props.customGroup.elementNamePattern,
+      {
+        nocomment: true,
+      },
+    )
+    if (!matchesElementNamePattern) {
+      return false
+    }
+  }
+  if (
+    'decoratorNamePattern' in props.customGroup &&
+    props.customGroup.decoratorNamePattern
+  ) {
+    let decoratorPattern = props.customGroup.decoratorNamePattern
+    let matchesDecoratorNamePattern = props.decorators.some(decorator =>
+      minimatch.minimatch(decorator, decoratorPattern, {
+        nocomment: true,
+      }),
+    )
+    if (!matchesDecoratorNamePattern) {
+      return false
+    }
+  }
+  return true
+}
+const getCompareOptions = (options, groupNumber) => {
+  let group = options.groups[groupNumber]
+  let customGroup =
+    typeof group === 'string' && Array.isArray(options.customGroups)
+      ? options.customGroups.find(g => group === g.groupName)
+      : null
+  if ((customGroup == null ? void 0 : customGroup.type) === 'unsorted') {
+    return null
+  }
+  return {
+    type: (customGroup == null ? void 0 : customGroup.type) ?? options.type,
+    order:
+      customGroup && 'order' in customGroup && customGroup.order
+        ? customGroup.order
+        : options.order,
+    ignoreCase: options.ignoreCase,
+  }
+}
+exports.customGroupMatches = customGroupMatches
 exports.generateOfficialGroups = generateOfficialGroups
+exports.getCompareOptions = getCompareOptions
+exports.getOverloadSignatureGroups = getOverloadSignatureGroups

package/dist/rules/sort-classes-utils.mjs

@@ -1,3 +1,4 @@
+import { minimatch } from 'minimatch'
 const cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 const generateOfficialGroups = (modifiers, selectors) => {
   let modifiersAndSelectorsKey = modifiers.join('&') + '/' + selectors.join('&')
@@ -63,4 +64,107 @@ const getPermutations = elements => {
   backtrack(0)
   return result
 }
-export { generateOfficialGroups }
+const getOverloadSignatureGroups = members => {
+  let methods = members
+    .filter(
+      member =>
+        member.type === 'MethodDefinition' ||
+        member.type === 'TSAbstractMethodDefinition',
+    )
+    .filter(member => member.kind === 'method')
+  let staticOverloadSignaturesByName = /* @__PURE__ */ new Map()
+  let overloadSignaturesByName = /* @__PURE__ */ new Map()
+  for (let method of methods) {
+    if (method.key.type !== 'Identifier') {
+      continue
+    }
+    let { name } = method.key
+    let mapToUse = method.static
+      ? staticOverloadSignaturesByName
+      : overloadSignaturesByName
+    let signatureOverloadsGroup = mapToUse.get(name)
+    if (!signatureOverloadsGroup) {
+      signatureOverloadsGroup = []
+      mapToUse.set(name, signatureOverloadsGroup)
+    }
+    signatureOverloadsGroup.push(method)
+  }
+  return [
+    ...overloadSignaturesByName.values(),
+    ...staticOverloadSignaturesByName.values(),
+  ].filter(group => group.length > 1)
+}
+const customGroupMatches = props => {
+  if ('anyOf' in props.customGroup) {
+    return props.customGroup.anyOf.some(subgroup =>
+      customGroupMatches({ ...props, customGroup: subgroup }),
+    )
+  }
+  if (
+    props.customGroup.selector &&
+    !props.selectors.includes(props.customGroup.selector)
+  ) {
+    return false
+  }
+  if (props.customGroup.modifiers) {
+    for (let modifier of props.customGroup.modifiers) {
+      if (!props.modifiers.includes(modifier)) {
+        return false
+      }
+    }
+  }
+  if (
+    'elementNamePattern' in props.customGroup &&
+    props.customGroup.elementNamePattern
+  ) {
+    let matchesElementNamePattern = minimatch(
+      props.elementName,
+      props.customGroup.elementNamePattern,
+      {
+        nocomment: true,
+      },
+    )
+    if (!matchesElementNamePattern) {
+      return false
+    }
+  }
+  if (
+    'decoratorNamePattern' in props.customGroup &&
+    props.customGroup.decoratorNamePattern
+  ) {
+    let decoratorPattern = props.customGroup.decoratorNamePattern
+    let matchesDecoratorNamePattern = props.decorators.some(decorator =>
+      minimatch(decorator, decoratorPattern, {
+        nocomment: true,
+      }),
+    )
+    if (!matchesDecoratorNamePattern) {
+      return false
+    }
+  }
+  return true
+}
+const getCompareOptions = (options, groupNumber) => {
+  let group = options.groups[groupNumber]
+  let customGroup =
+    typeof group === 'string' && Array.isArray(options.customGroups)
+      ? options.customGroups.find(g => group === g.groupName)
+      : null
+  if ((customGroup == null ? void 0 : customGroup.type) === 'unsorted') {
+    return null
+  }
+  return {
+    type: (customGroup == null ? void 0 : customGroup.type) ?? options.type,
+    order:
+      customGroup && 'order' in customGroup && customGroup.order
+        ? customGroup.order
+        : options.order,
+    ignoreCase: options.ignoreCase,
+  }
+}
+export {
+  customGroupMatches,
+  generateOfficialGroups,
+  getCompareOptions,
+  getOverloadSignatureGroups,
+}