eslint-plugin-perfectionist 4.1.2 → 4.3.0

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

@@ -1,16 +1,26 @@
 'use strict'
+Object.defineProperties(exports, {
+  __esModule: { value: true },
+  [Symbol.toStringTag]: { value: 'Module' },
+})
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
-const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
+const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
+const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
+const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
+const sortObjectTypes_types = require('./sort-object-types.types.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
+const isNodeFunctionType = require('../utils/is-node-function-type.js')
 const sortNodesByGroups = require('../utils/sort-nodes-by-groups.js')
 const getCommentsBefore = require('../utils/get-comments-before.js')
 const makeNewlinesFixes = require('../utils/make-newlines-fixes.js')
 const getNewlinesErrors = require('../utils/get-newlines-errors.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const isMemberOptional = require('../utils/is-member-optional.js')
+const sortObjectTypesUtils = require('./sort-object-types-utils.js')
 const getLinesBetween = require('../utils/get-lines-between.js')
 const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -22,6 +32,8 @@ const makeFixes = require('../utils/make-fixes.js')
 const useGroups = require('../utils/use-groups.js')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
+const matches = require('../utils/matches.js')
+let cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 let defaultOptions = {
   partitionByComment: false,
   partitionByNewLine: false,
@@ -29,235 +41,58 @@ let defaultOptions = {
   specialCharacters: 'keep',
   type: 'alphabetical',
   groupKind: 'mixed',
+  ignorePattern: [],
   ignoreCase: true,
   customGroups: {},
   locales: 'en-US',
+  alphabet: '',
   order: 'asc',
   groups: [],
 }
-const sortObjectTypes = createEslintRule.createEslintRule({
-  create: context => ({
-    TSTypeLiteral: node => {
-      if (!isSortable.isSortable(node.members)) {
-        return
-      }
-      let settings = getSettings.getSettings(context.settings)
-      let options = complete.complete(
-        context.options.at(0),
-        settings,
-        defaultOptions,
-      )
-      validateGroupsConfiguration.validateGroupsConfiguration(
-        options.groups,
-        ['multiline', 'method', 'unknown'],
-        Object.keys(options.customGroups),
-      )
-      validateNewlinesAndPartitionConfiguration.validateNewlinesAndPartitionConfiguration(
-        options,
-      )
-      let sourceCode = getSourceCode.getSourceCode(context)
-      let eslintDisabledLines = getEslintDisabledLines.getEslintDisabledLines({
-        ruleName: context.id,
-        sourceCode,
-      })
-      let formattedMembers = node.members.reduce(
-        (accumulator, member) => {
-          var _a, _b, _c, _d, _e
-          let name
-          let lastSortingNode =
-            (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
-          let { setCustomGroups, defineGroup, getGroup } =
-            useGroups.useGroups(options)
-          let formatName = value => value.replace(/[,;]$/u, '')
-          if (member.type === 'TSPropertySignature') {
-            if (member.key.type === 'Identifier') {
-              ;({ name } = member.key)
-            } else if (member.key.type === 'Literal') {
-              name = `${member.key.value}`
-            } else {
-              name = sourceCode.text.slice(
-                member.range.at(0),
-                ((_b = member.typeAnnotation) == null
-                  ? void 0
-                  : _b.range.at(0)) ?? member.range.at(1),
-              )
-            }
-          } else if (member.type === 'TSIndexSignature') {
-            let endIndex =
-              ((_c = member.typeAnnotation) == null
-                ? void 0
-                : _c.range.at(0)) ?? member.range.at(1)
-            name = formatName(
-              sourceCode.text.slice(member.range.at(0), endIndex),
-            )
-          } else {
-            name = formatName(
-              sourceCode.text.slice(member.range.at(0), member.range.at(1)),
-            )
-          }
-          setCustomGroups(options.customGroups, name)
-          if (
-            member.type === 'TSMethodSignature' ||
-            (member.type === 'TSPropertySignature' &&
-              ((_d = member.typeAnnotation) == null
-                ? void 0
-                : _d.typeAnnotation.type) === 'TSFunctionType')
-          ) {
-            defineGroup('method')
-          }
-          if (member.loc.start.line !== member.loc.end.line) {
-            defineGroup('multiline')
-          }
-          let sortingNode = {
-            isEslintDisabled: isNodeEslintDisabled.isNodeEslintDisabled(
-              member,
-              eslintDisabledLines,
-            ),
-            groupKind: isMemberOptional.isMemberOptional(member)
-              ? 'optional'
-              : 'required',
-            size: rangeToDiff.rangeToDiff(member, sourceCode),
-            addSafetySemicolonWhenInline: true,
-            group: getGroup(),
-            node: member,
-            name,
-          }
-          if (
-            (options.partitionByComment &&
-              isPartitionComment.hasPartitionComment(
-                options.partitionByComment,
-                getCommentsBefore.getCommentsBefore(member, sourceCode),
-              )) ||
-            (options.partitionByNewLine &&
-              lastSortingNode &&
-              getLinesBetween.getLinesBetween(
-                sourceCode,
-                lastSortingNode,
-                sortingNode,
-              ))
-          ) {
-            accumulator.push([])
-          }
-          ;(_e = accumulator.at(-1)) == null ? void 0 : _e.push(sortingNode)
-          return accumulator
-        },
-        [[]],
-      )
-      let groupKindOrder
-      if (options.groupKind === 'required-first') {
-        groupKindOrder = ['required', 'optional']
-      } else if (options.groupKind === 'optional-first') {
-        groupKindOrder = ['optional', 'required']
-      } else {
-        groupKindOrder = ['any']
-      }
-      for (let nodes of formattedMembers) {
-        let filteredGroupKindNodes = groupKindOrder.map(groupKind =>
-          nodes.filter(
-            currentNode =>
-              groupKind === 'any' || currentNode.groupKind === groupKind,
-          ),
-        )
-        let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
-          filteredGroupKindNodes.flatMap(groupedNodes =>
-            sortNodesByGroups.sortNodesByGroups(groupedNodes, options, {
-              ignoreEslintDisabledNodes,
-            }),
-          )
-        let sortedNodes = sortNodesExcludingEslintDisabled(false)
-        let sortedNodesExcludingEslintDisabled =
-          sortNodesExcludingEslintDisabled(true)
-        pairwise.pairwise(nodes, (left, right) => {
-          let leftNumber = getGroupNumber.getGroupNumber(options.groups, left)
-          let rightNumber = getGroupNumber.getGroupNumber(options.groups, right)
-          let indexOfLeft = sortedNodes.indexOf(left)
-          let indexOfRight = sortedNodes.indexOf(right)
-          let indexOfRightExcludingEslintDisabled =
-            sortedNodesExcludingEslintDisabled.indexOf(right)
-          let messageIds = []
-          if (
-            indexOfLeft > indexOfRight ||
-            indexOfLeft >= indexOfRightExcludingEslintDisabled
-          ) {
-            messageIds.push(
-              leftNumber === rightNumber
-                ? 'unexpectedObjectTypesOrder'
-                : 'unexpectedObjectTypesGroupOrder',
-            )
-          }
-          messageIds = [
-            ...messageIds,
-            ...getNewlinesErrors.getNewlinesErrors({
-              missedSpacingError: 'missedSpacingBetweenObjectTypeMembers',
-              extraSpacingError: 'extraSpacingBetweenObjectTypeMembers',
-              rightNum: rightNumber,
-              leftNum: leftNumber,
-              sourceCode,
-              options,
-              right,
-              left,
-            }),
-          ]
-          for (let messageId of messageIds) {
-            context.report({
-              fix: fixer => [
-                ...makeFixes.makeFixes({
-                  sortedNodes: sortedNodesExcludingEslintDisabled,
-                  sourceCode,
-                  options,
-                  fixer,
-                  nodes,
-                }),
-                ...makeNewlinesFixes.makeNewlinesFixes({
-                  sortedNodes: sortedNodesExcludingEslintDisabled,
-                  sourceCode,
-                  options,
-                  fixer,
-                  nodes,
-                }),
-              ],
-              data: {
-                right: toSingleLine.toSingleLine(right.name),
-                left: toSingleLine.toSingleLine(left.name),
-                rightGroup: right.group,
-                leftGroup: left.group,
-              },
-              node: right.node,
-              messageId,
-            })
-          }
-        })
-      }
+let jsonSchema = {
+  properties: {
+    ignorePattern: {
+      description:
+        'Specifies names or patterns for nodes that should be ignored by rule.',
+      items: {
+        type: 'string',
+      },
+      type: 'array',
     },
-  }),
+    partitionByComment: {
+      ...commonJsonSchemas.partitionByCommentJsonSchema,
+      description:
+        'Allows you to use comments to separate members into logical groups.',
+    },
+    customGroups: {
+      oneOf: [
+        commonJsonSchemas.customGroupsJsonSchema,
+        commonJsonSchemas.buildCustomGroupsArrayJsonSchema({
+          singleCustomGroupJsonSchema:
+            sortObjectTypes_types.singleCustomGroupJsonSchema,
+        }),
+      ],
+    },
+    groupKind: {
+      enum: ['mixed', 'required-first', 'optional-first'],
+      description: 'Specifies top-level groups.',
+      type: 'string',
+    },
+    partitionByNewLine: commonJsonSchemas.partitionByNewLineJsonSchema,
+    specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
+    newlinesBetween: commonJsonSchemas.newlinesBetweenJsonSchema,
+    ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+    alphabet: commonJsonSchemas.alphabetJsonSchema,
+    locales: commonJsonSchemas.localesJsonSchema,
+    groups: commonJsonSchemas.groupsJsonSchema,
+    order: commonJsonSchemas.orderJsonSchema,
+    type: commonJsonSchemas.typeJsonSchema,
+  },
+  additionalProperties: false,
+  type: 'object',
+}
+const sortObjectTypes = createEslintRule.createEslintRule({
   meta: {
-    schema: [
-      {
-        properties: {
-          partitionByComment: {
-            ...commonJsonSchemas.partitionByCommentJsonSchema,
-            description:
-              'Allows you to use comments to separate the type members into logical groups.',
-          },
-          groupKind: {
-            enum: ['mixed', 'required-first', 'optional-first'],
-            description: 'Specifies top-level groups.',
-            type: 'string',
-          },
-          partitionByNewLine: commonJsonSchemas.partitionByNewLineJsonSchema,
-          specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
-          newlinesBetween: commonJsonSchemas.newlinesBetweenJsonSchema,
-          customGroups: commonJsonSchemas.customGroupsJsonSchema,
-          ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
-          locales: commonJsonSchemas.localesJsonSchema,
-          groups: commonJsonSchemas.groupsJsonSchema,
-          order: commonJsonSchemas.orderJsonSchema,
-          type: commonJsonSchemas.typeJsonSchema,
-        },
-        additionalProperties: false,
-        type: 'object',
-      },
-    ],
     messages: {
       unexpectedObjectTypesGroupOrder:
         'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
@@ -273,10 +108,297 @@ const sortObjectTypes = createEslintRule.createEslintRule({
       description: 'Enforce sorted object types.',
       recommended: true,
     },
+    schema: [jsonSchema],
     type: 'suggestion',
     fixable: 'code',
   },
+  create: context => ({
+    TSTypeLiteral: node =>
+      sortObjectTypeElements({
+        availableMessageIds: {
+          missedSpacingBetweenMembers: 'missedSpacingBetweenObjectTypeMembers',
+          extraSpacingBetweenMembers: 'extraSpacingBetweenObjectTypeMembers',
+          unexpectedGroupOrder: 'unexpectedObjectTypesGroupOrder',
+          unexpectedOrder: 'unexpectedObjectTypesOrder',
+        },
+        parentNodeName:
+          node.parent.type === 'TSTypeAliasDeclaration'
+            ? node.parent.id.name
+            : null,
+        elements: node.members,
+        context,
+      }),
+  }),
   defaultOptions: [defaultOptions],
   name: 'sort-object-types',
 })
-module.exports = sortObjectTypes
+let sortObjectTypeElements = ({
+  availableMessageIds,
+  parentNodeName,
+  elements,
+  context,
+}) => {
+  if (!isSortable.isSortable(elements)) {
+    return
+  }
+  let settings = getSettings.getSettings(context.settings)
+  let options = complete.complete(
+    context.options.at(0),
+    settings,
+    defaultOptions,
+  )
+  validateCustomSortConfiguration.validateCustomSortConfiguration(options)
+  validateGeneratedGroupsConfiguration.validateGeneratedGroupsConfiguration({
+    customGroups: options.customGroups,
+    selectors: sortObjectTypes_types.allSelectors,
+    modifiers: sortObjectTypes_types.allModifiers,
+    groups: options.groups,
+  })
+  validateNewlinesAndPartitionConfiguration.validateNewlinesAndPartitionConfiguration(
+    options,
+  )
+  if (
+    options.ignorePattern.some(
+      pattern => parentNodeName && matches.matches(parentNodeName, pattern),
+    )
+  ) {
+    return
+  }
+  let sourceCode = getSourceCode.getSourceCode(context)
+  let eslintDisabledLines = getEslintDisabledLines.getEslintDisabledLines({
+    ruleName: context.id,
+    sourceCode,
+  })
+  let formattedMembers = elements.reduce(
+    (accumulator, typeElement) => {
+      var _a, _b, _c, _d
+      if (typeElement.type === 'TSCallSignatureDeclaration') {
+        accumulator.push([])
+        return accumulator
+      }
+      let name
+      let lastSortingNode =
+        (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
+      let { setCustomGroups, defineGroup, getGroup } =
+        useGroups.useGroups(options)
+      let formatName = value => value.replace(/[,;]$/u, '')
+      if (typeElement.type === 'TSPropertySignature') {
+        if (typeElement.key.type === 'Identifier') {
+          ;({ name } = typeElement.key)
+        } else if (typeElement.key.type === 'Literal') {
+          name = `${typeElement.key.value}`
+        } else {
+          let end =
+            ((_b = typeElement.typeAnnotation) == null
+              ? void 0
+              : _b.range.at(0)) ??
+            typeElement.range.at(1) - (typeElement.optional ? '?'.length : 0)
+          name = sourceCode.text.slice(typeElement.range.at(0), end)
+        }
+      } else if (typeElement.type === 'TSIndexSignature') {
+        let endIndex =
+          ((_c = typeElement.typeAnnotation) == null
+            ? void 0
+            : _c.range.at(0)) ?? typeElement.range.at(1)
+        name = formatName(
+          sourceCode.text.slice(typeElement.range.at(0), endIndex),
+        )
+      } else if (
+        typeElement.type === 'TSMethodSignature' &&
+        'name' in typeElement.key
+      ) {
+        ;({ name } = typeElement.key)
+      } else {
+        name = formatName(
+          sourceCode.text.slice(
+            typeElement.range.at(0),
+            typeElement.range.at(1),
+          ),
+        )
+      }
+      let selectors = []
+      let modifiers = []
+      if (typeElement.type === 'TSIndexSignature') {
+        selectors.push('index-signature')
+      }
+      if (isNodeFunctionType.isNodeFunctionType(typeElement)) {
+        selectors.push('method')
+      }
+      if (typeElement.loc.start.line !== typeElement.loc.end.line) {
+        modifiers.push('multiline')
+        selectors.push('multiline')
+      }
+      if (
+        !selectors.includes('index-signature') &&
+        !selectors.includes('method')
+      ) {
+        selectors.push('property')
+      }
+      selectors.push('member')
+      if (isMemberOptional.isMemberOptional(typeElement)) {
+        modifiers.push('optional')
+      } else {
+        modifiers.push('required')
+      }
+      for (let predefinedGroup of generatePredefinedGroups.generatePredefinedGroups(
+        {
+          cache: cachedGroupsByModifiersAndSelectors,
+          selectors,
+          modifiers,
+        },
+      )) {
+        defineGroup(predefinedGroup)
+      }
+      if (Array.isArray(options.customGroups)) {
+        for (let customGroup of options.customGroups) {
+          if (
+            sortObjectTypesUtils.customGroupMatches({
+              elementName: name,
+              customGroup,
+              selectors,
+              modifiers,
+            })
+          ) {
+            defineGroup(customGroup.groupName, true)
+            if (getGroup() === customGroup.groupName) {
+              break
+            }
+          }
+        }
+      } else {
+        setCustomGroups(options.customGroups, name, {
+          override: true,
+        })
+      }
+      let sortingNode = {
+        isEslintDisabled: isNodeEslintDisabled.isNodeEslintDisabled(
+          typeElement,
+          eslintDisabledLines,
+        ),
+        groupKind: isMemberOptional.isMemberOptional(typeElement)
+          ? 'optional'
+          : 'required',
+        size: rangeToDiff.rangeToDiff(typeElement, sourceCode),
+        addSafetySemicolonWhenInline: true,
+        group: getGroup(),
+        node: typeElement,
+        name,
+      }
+      if (
+        (options.partitionByComment &&
+          isPartitionComment.hasPartitionComment(
+            options.partitionByComment,
+            getCommentsBefore.getCommentsBefore({
+              node: typeElement,
+              sourceCode,
+            }),
+          )) ||
+        (options.partitionByNewLine &&
+          lastSortingNode &&
+          getLinesBetween.getLinesBetween(
+            sourceCode,
+            lastSortingNode,
+            sortingNode,
+          ))
+      ) {
+        accumulator.push([])
+      }
+      ;(_d = accumulator.at(-1)) == null ? void 0 : _d.push(sortingNode)
+      return accumulator
+    },
+    [[]],
+  )
+  let groupKindOrder
+  if (options.groupKind === 'required-first') {
+    groupKindOrder = ['required', 'optional']
+  } else if (options.groupKind === 'optional-first') {
+    groupKindOrder = ['optional', 'required']
+  } else {
+    groupKindOrder = ['any']
+  }
+  for (let nodes of formattedMembers) {
+    let filteredGroupKindNodes = groupKindOrder.map(groupKind =>
+      nodes.filter(
+        currentNode =>
+          groupKind === 'any' || currentNode.groupKind === groupKind,
+      ),
+    )
+    let sortNodesExcludingEslintDisabled = ignoreEslintDisabledNodes =>
+      filteredGroupKindNodes.flatMap(groupedNodes =>
+        sortNodesByGroups.sortNodesByGroups(groupedNodes, options, {
+          getGroupCompareOptions: groupNumber =>
+            getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
+              options,
+              groupNumber,
+            ),
+          ignoreEslintDisabledNodes,
+        }),
+      )
+    let sortedNodes = sortNodesExcludingEslintDisabled(false)
+    let sortedNodesExcludingEslintDisabled =
+      sortNodesExcludingEslintDisabled(true)
+    pairwise.pairwise(nodes, (left, right) => {
+      let leftNumber = getGroupNumber.getGroupNumber(options.groups, left)
+      let rightNumber = getGroupNumber.getGroupNumber(options.groups, right)
+      let indexOfLeft = sortedNodes.indexOf(left)
+      let indexOfRight = sortedNodes.indexOf(right)
+      let indexOfRightExcludingEslintDisabled =
+        sortedNodesExcludingEslintDisabled.indexOf(right)
+      let messageIds = []
+      if (
+        indexOfLeft > indexOfRight ||
+        indexOfLeft >= indexOfRightExcludingEslintDisabled
+      ) {
+        messageIds.push(
+          leftNumber === rightNumber
+            ? availableMessageIds.unexpectedOrder
+            : availableMessageIds.unexpectedGroupOrder,
+        )
+      }
+      messageIds = [
+        ...messageIds,
+        ...getNewlinesErrors.getNewlinesErrors({
+          missedSpacingError: availableMessageIds.missedSpacingBetweenMembers,
+          extraSpacingError: availableMessageIds.extraSpacingBetweenMembers,
+          rightNum: rightNumber,
+          leftNum: leftNumber,
+          sourceCode,
+          options,
+          right,
+          left,
+        }),
+      ]
+      for (let messageId of messageIds) {
+        context.report({
+          fix: fixer => [
+            ...makeFixes.makeFixes({
+              sortedNodes: sortedNodesExcludingEslintDisabled,
+              sourceCode,
+              options,
+              fixer,
+              nodes,
+            }),
+            ...makeNewlinesFixes.makeNewlinesFixes({
+              sortedNodes: sortedNodesExcludingEslintDisabled,
+              sourceCode,
+              options,
+              fixer,
+              nodes,
+            }),
+          ],
+          data: {
+            right: toSingleLine.toSingleLine(right.name),
+            left: toSingleLine.toSingleLine(left.name),
+            rightGroup: right.group,
+            leftGroup: left.group,
+          },
+          node: right.node,
+          messageId,
+        })
+      }
+    })
+  }
+}
+exports.default = sortObjectTypes
+exports.jsonSchema = jsonSchema
+exports.sortObjectTypeElements = sortObjectTypeElements

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

@@ -0,0 +1,20 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const commonJsonSchemas = require('../utils/common-json-schemas.js')
+let allSelectors = [
+  'index-signature',
+  'member',
+  'method',
+  'multiline',
+  'property',
+]
+let allModifiers = ['optional', 'required', 'multiline']
+let singleCustomGroupJsonSchema = {
+  modifiers:
+    commonJsonSchemas.buildCustomGroupModifiersJsonSchema(allModifiers),
+  selector: commonJsonSchemas.buildCustomGroupSelectorJsonSchema(allSelectors),
+  elementNamePattern: commonJsonSchemas.elementNamePatternJsonSchema,
+}
+exports.allModifiers = allModifiers
+exports.allSelectors = allSelectors
+exports.singleCustomGroupJsonSchema = singleCustomGroupJsonSchema