eslint-plugin-perfectionist 5.10.0 → 5.10.1

package/dist/package.json.js

@@ -1,3 +1,3 @@
 var name = 'eslint-plugin-perfectionist'
-var version = '5.10.0'
+var version = '5.10.1'
 export { name, version }

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

@@ -73,6 +73,11 @@ function sortArray({
         sourceCode,
       })
       let selector = 'literal'
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors: [selector],
+        modifiers: [],
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -81,11 +86,7 @@ function sortArray({
             modifiers: [],
             customGroup,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors: [selector],
-          modifiers: [],
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {
@@ -125,12 +126,13 @@ function sortArray({
       }),
     )
   }
+  let nodes = formattedMembers.flat()
   reportAllErrors({
     sortNodesExcludingEslintDisabled,
     availableMessageIds,
     options,
     context,
-    nodes: formattedMembers.flat(),
+    nodes,
   })
 }
 export { sortArray }

package/dist/rules/sort-classes/compute-dependencies-by-sorting-node.js

@@ -10,11 +10,12 @@ function computeDependenciesBySortingNode({
   sourceCode,
   classBody,
 }) {
+  let staticSortingNodes = sortingNodes.filter(node => node.isStatic)
   let dependenciesBySortingNode = computeDependenciesBySortingNode$1({
     additionalIdentifierDependenciesComputer:
       buildAdditionalIdentifierDependenciesComputer({
         ignoreCallbackDependenciesPatterns,
-        staticSortingNodes: sortingNodes.filter(node => node.isStatic),
+        staticSortingNodes,
         classBody,
       }),
     shouldIgnoreSortingNodeComputer: sortingNode =>
@@ -73,22 +74,21 @@ function computeIdentifierOrThisExpressionDependency({
     }
   }
   function shouldIgnoreCallbackDependency() {
-    let [firstCallExpressionParent] = computeParentNodesWithTypes({
+    return computeParentNodesWithTypes({
       allowedTypes: [AST_NODE_TYPES.CallExpression],
       maxParent: classElement,
       consecutiveOnly: false,
       node,
-    })
-    if (!firstCallExpressionParent) {
-      return false
-    }
-    if (!('name' in firstCallExpressionParent.callee)) {
-      return false
+    }).some(shouldIgnoreCallExpression)
+    function shouldIgnoreCallExpression(callExpressionParent) {
+      return (
+        'name' in callExpressionParent.callee &&
+        matches(
+          callExpressionParent.callee.name,
+          ignoreCallbackDependenciesPatterns,
+        )
+      )
     }
-    return matches(
-      firstCallExpressionParent.callee.name,
-      ignoreCallbackDependenciesPatterns,
-    )
   }
 }
 function computeThisExpressionDependenciesBySortingNode({

package/dist/rules/sort-classes/compute-dependencies.js

@@ -63,9 +63,6 @@ function computeDependencies({
       case AST_NODE_TYPES.Property:
         traverseNode(nodeValue.key)
         traverseNode(nodeValue.value)
-        break
-      default:
-        break
     }
     if ('argument' in nodeValue && nodeValue.argument) {
       traverseNode(nodeValue.argument)

package/dist/rules/sort-classes/compute-overload-signature-groups.js

@@ -41,10 +41,11 @@ function computeOverloadSignatureGroups(classElements) {
 }
 function buildOverloadSignatureGroup(methods) {
   let implementation = methods.find(isMethodImplementation) ?? methods.at(-1)
+  let overloadSignatures = methods.filter(
+    method => !isMethodImplementation(method),
+  )
   return new OverloadSignatureGroup({
-    overloadSignatures: methods.filter(
-      method => !isMethodImplementation(method),
-    ),
+    overloadSignatures,
     implementation,
   })
   function isMethodImplementation(method) {

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

@@ -94,15 +94,12 @@ function sortClass({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      classElements,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    classElements,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     modifiers: allModifiers,
@@ -235,6 +232,11 @@ function sortClass({ matchedAstSelectors, context, node }) {
         default:
           throw new UnreachableCaseError(member)
       }
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors,
+        modifiers,
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -245,11 +247,7 @@ function sortClass({ matchedAstSelectors, context, node }) {
             modifiers,
             selectors,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors,
-          modifiers,
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {
@@ -288,14 +286,15 @@ function sortClass({ matchedAstSelectors, context, node }) {
     sortingNodeGroups: sortingNodeGroupsWithoutOverloadSignature,
   })
   if (options.useExperimentalDependencyDetection) {
+    let dependenciesBySortingNode = computeDependenciesBySortingNode({
+      ignoreCallbackDependenciesPatterns:
+        options.ignoreCallbackDependenciesPatterns,
+      sortingNodes: sortingNodeGroups.flat(),
+      classBody: node,
+      sourceCode,
+    })
     sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
-      dependenciesBySortingNode: computeDependenciesBySortingNode({
-        ignoreCallbackDependenciesPatterns:
-          options.ignoreCallbackDependenciesPatterns,
-        sortingNodes: sortingNodeGroups.flat(),
-        classBody: node,
-        sourceCode,
-      }),
+      dependenciesBySortingNode,
       sortingNodeGroups,
     })
   }
@@ -315,21 +314,20 @@ function sortClass({ matchedAstSelectors, context, node }) {
     context,
   })
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-    return sortNodesByDependencies(
-      sortingNodeGroups.flatMap(sortingNodeGroup =>
-        sortNodesByGroups({
-          isNodeIgnored: sortingNode =>
-            getGroupIndex(options.groups, sortingNode) ===
-            options.groups.length,
-          comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
-          optionsByGroupIndexComputer,
-          ignoreEslintDisabledNodes,
-          nodes: sortingNodeGroup,
-          groups: options.groups,
-        }),
-      ),
-      { ignoreEslintDisabledNodes },
+    let nodesSortedByGroups = sortingNodeGroups.flatMap(sortingNodeGroup =>
+      sortNodesByGroups({
+        isNodeIgnored: sortingNode =>
+          getGroupIndex(options.groups, sortingNode) === options.groups.length,
+        comparatorByOptionsComputer: defaultComparatorByOptionsComputer,
+        optionsByGroupIndexComputer,
+        ignoreEslintDisabledNodes,
+        nodes: sortingNodeGroup,
+        groups: options.groups,
+      }),
     )
+    return sortNodesByDependencies(nodesSortedByGroups, {
+      ignoreEslintDisabledNodes,
+    })
   }
 }
 export { defaultOptions, sortClass }

package/dist/rules/sort-enums/compute-dependencies.js

@@ -31,9 +31,6 @@ function computeDependencies(expression, enumName) {
         break
       case AST_NODE_TYPES.Identifier:
         dependencies.push(node.name)
-        break
-      default:
-        break
     }
     if ('alternate' in node && node.alternate) {
       stack.push(node.alternate)

package/dist/rules/sort-enums/sort-enum.js

@@ -54,15 +54,12 @@ function sortEnum({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      enumMembers: members,
-      matchedAstSelectors,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    enumMembers: members,
+    matchedAstSelectors,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     selectors: [],
@@ -131,12 +128,13 @@ function sortEnum({ matchedAstSelectors, context, node }) {
     [[]],
   )
   if (options.useExperimentalDependencyDetection) {
+    let dependenciesBySortingNode = computeDependenciesBySortingNode({
+      sortingNodes: sortingNodeGroups.flat(),
+      enumName: node.id.name,
+      sourceCode,
+    })
     sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
-      dependenciesBySortingNode: computeDependenciesBySortingNode({
-        sortingNodes: sortingNodeGroups.flat(),
-        enumName: node.id.name,
-        sourceCode,
-      }),
+      dependenciesBySortingNode,
       sortingNodeGroups,
     })
   }
@@ -158,19 +156,19 @@ function sortEnum({ matchedAstSelectors, context, node }) {
     context,
   })
   function sortNodesExcludingEslintDisabled(ignoreEslintDisabledNodes) {
-    return sortNodesByDependencies(
-      sortingNodeGroups.flatMap(sortingNodeGroup =>
-        sortNodesByGroups({
-          comparatorByOptionsComputer:
-            buildComparatorByOptionsComputer(isNumericEnum),
-          optionsByGroupIndexComputer,
-          ignoreEslintDisabledNodes,
-          nodes: sortingNodeGroup,
-          groups: options.groups,
-        }),
-      ),
-      { ignoreEslintDisabledNodes },
+    let nodesSortedByGroups = sortingNodeGroups.flatMap(sortingNodeGroup =>
+      sortNodesByGroups({
+        comparatorByOptionsComputer:
+          buildComparatorByOptionsComputer(isNumericEnum),
+        optionsByGroupIndexComputer,
+        ignoreEslintDisabledNodes,
+        nodes: sortingNodeGroup,
+        groups: options.groups,
+      }),
     )
+    return sortNodesByDependencies(nodesSortedByGroups, {
+      ignoreEslintDisabledNodes,
+    })
   }
 }
 export { defaultOptions, sortEnum }

package/dist/rules/sort-exports.js

@@ -88,6 +88,11 @@ var sort_exports_default = createEslintRule({
         computeLineCountModifier(node),
       ]
       let name = node.source.value
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors: [selector],
+        modifiers,
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -96,11 +101,7 @@ var sort_exports_default = createEslintRule({
             customGroup,
             modifiers,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors: [selector],
-          modifiers,
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {

package/dist/rules/sort-heritage-clauses/sort-heritage-clause.js

@@ -48,15 +48,12 @@ function sortHeritageClause({ matchedAstSelectors, context, node }) {
     return
   }
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      heritageClauses,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    heritageClauses,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     modifiers: [],

package/dist/rules/sort-import-attributes/sort-import-or-export-attributes.js

@@ -29,15 +29,12 @@ function sortImportOrExportAttributes({
   }
   let { sourceCode, id } = context
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      attributes,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    attributes,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     selectors: [],

package/dist/rules/sort-imports/compute-common-selectors.js

@@ -135,7 +135,7 @@ function isCoreModule(value, environment) {
   function clean(string_) {
     return string_.replace(/^(?:node:){1,2}/u, '')
   }
-  let [basePath] = value.split('/')
+  let [basePath] = value.split('/', 1)
   let cleanValue = clean(value)
   let cleanBase = clean(basePath)
   if (nodeBuiltinModules.has(cleanValue) || nodeBuiltinModules.has(cleanBase)) {

package/dist/rules/sort-imports/get-typescript-import.d.ts

@@ -1,7 +1,20 @@
 import { default as ts } from 'typescript'
+declare let requiredTypescriptAttributes: [
+  'createModuleResolutionCache',
+  'isExternalModuleNameRelative',
+  'parseJsonConfigFileContent',
+  'readConfigFile',
+  'resolveModuleName',
+  'sys',
+]
+export type TypescriptImport = Pick<
+  typeof ts,
+  (typeof requiredTypescriptAttributes)[number]
+>
 /**
  * Dynamically loads the typescript module if it's available and caches it.
  *
  * @returns The TypeScript module or null if it's not available.
  */
-export declare function getTypescriptImport(): typeof ts | null
+export declare function getTypescriptImport(): TypescriptImport | null
+export {}

package/dist/rules/sort-imports/get-typescript-import.js

@@ -8,6 +8,14 @@ var cachedImport
  * made.
  */
 var hasTriedLoadingTypescript = false
+var requiredTypescriptAttributes = [
+  'createModuleResolutionCache',
+  'isExternalModuleNameRelative',
+  'parseJsonConfigFileContent',
+  'readConfigFile',
+  'resolveModuleName',
+  'sys',
+]
 /**
  * Dynamically loads the typescript module if it's available and caches it.
  *
@@ -22,10 +30,19 @@ function getTypescriptImport() {
   }
   hasTriedLoadingTypescript = true
   try {
-    cachedImport = createRequire(import.meta.url)('typescript')
+    let tsImport = createRequire(import.meta.url)('typescript')
+    if (!isSupportedTypescriptVersion(tsImport)) {
+      return null
+    }
+    cachedImport = tsImport
+    return cachedImport
   } catch (_error) {
     return null
   }
-  return cachedImport
+}
+function isSupportedTypescriptVersion(typescriptImport) {
+  return requiredTypescriptAttributes.every(attribute =>
+    Object.hasOwn(typescriptImport, attribute),
+  )
 }
 export { getTypescriptImport }

package/dist/rules/sort-imports/read-closest-ts-config-by-path.js

@@ -84,27 +84,22 @@ function getCompilerOptions(typescriptImport, contextCwd, filePath) {
     )
   }
   let parsedContent = typescriptImport.parseJsonConfigFileContent(
-    configFileRead,
+    configFileRead.config,
     typescriptImport.sys,
     path.dirname(filePath),
   )
-  let compilerOptionsConverted =
-    typescriptImport.convertCompilerOptionsFromJson(
-      parsedContent.raw.config.compilerOptions,
-      path.dirname(filePath),
-    )
-  if (compilerOptionsConverted.errors.length > 0) {
+  if (parsedContent.errors.length > 0) {
     throw new Error(
-      `Error getting compiler options: ${JSON.stringify(compilerOptionsConverted.errors)}`,
+      `Error getting compiler options: ${JSON.stringify(parsedContent.errors)}`,
     )
   }
   let cache = typescriptImport.createModuleResolutionCache(
     contextCwd,
     fileName => typescriptImport.sys.resolvePath(fileName),
-    compilerOptionsConverted.options,
+    parsedContent.options,
   )
   let output = {
-    compilerOptions: compilerOptionsConverted.options,
+    compilerOptions: parsedContent.options,
     cache,
   }
   contentCacheByPath.set(filePath, output)

package/dist/rules/sort-imports.js

@@ -102,8 +102,9 @@ var defaultOptions = {
 var sort_imports_default = createEslintRule({
   create: context => {
     let settings = getSettings(context.settings)
+    let userOptions = context.options.at(0)
     let options = getOptionsWithCleanGroups(
-      complete(context.options.at(0), settings, defaultOptions),
+      complete(userOptions, settings, defaultOptions),
     )
     validateGroupsConfig({
       selectors: allSelectors,
@@ -364,11 +365,12 @@ function sortImportNodes({ sortingNodesWithoutPartitionId, options, context }) {
   for (let contentSeparatedSortingNodeGroup of contentSeparatedSortingNodeGroups) {
     let sortingNodeGroups = [...contentSeparatedSortingNodeGroup]
     if (options.useExperimentalDependencyDetection) {
+      let dependenciesBySortingNode = computeDependenciesBySortingNode({
+        sortingNodes: sortingNodeGroups.flat(),
+        sourceCode,
+      })
       sortingNodeGroups = populateSortingNodeGroupsWithDependencies({
-        dependenciesBySortingNode: computeDependenciesBySortingNode({
-          sortingNodes: sortingNodeGroups.flat(),
-          sourceCode,
-        }),
+        dependenciesBySortingNode,
         sortingNodeGroups,
       })
     }
@@ -391,25 +393,25 @@ function sortImportNodes({ sortingNodesWithoutPartitionId, options, context }) {
   }
   function createSortNodesExcludingEslintDisabled(nodeGroups) {
     return function (ignoreEslintDisabledNodes) {
-      return sortNodesByDependencies(
-        nodeGroups.flatMap(nodes =>
-          sortNodesByGroups({
-            isNodeIgnoredForGroup: ({ groupIndex }) => {
-              if (options.sortSideEffects) {
-                return false
-              }
-              return isSideEffectOnlyGroup(options.groups[groupIndex])
-            },
-            isNodeIgnored: node => node.isIgnored,
-            optionsByGroupIndexComputer,
-            comparatorByOptionsComputer,
-            ignoreEslintDisabledNodes,
-            groups: options.groups,
-            nodes,
-          }),
-        ),
-        { ignoreEslintDisabledNodes },
+      let nodesSortedByGroups = nodeGroups.flatMap(nodes =>
+        sortNodesByGroups({
+          isNodeIgnoredForGroup: ({ groupIndex }) => {
+            if (options.sortSideEffects) {
+              return false
+            }
+            return isSideEffectOnlyGroup(options.groups[groupIndex])
+          },
+          isNodeIgnored: node => node.isIgnored,
+          optionsByGroupIndexComputer,
+          comparatorByOptionsComputer,
+          ignoreEslintDisabledNodes,
+          groups: options.groups,
+          nodes,
+        }),
       )
+      return sortNodesByDependencies(nodesSortedByGroups, {
+        ignoreEslintDisabledNodes,
+      })
     }
   }
   function hasContentBetweenNodes(left, right) {
@@ -421,6 +423,11 @@ function sortImportNodes({ sortingNodesWithoutPartitionId, options, context }) {
   }
 }
 function computeGroupExceptUnknown({ selectors, modifiers, options, name }) {
+  let predefinedGroups = generatePredefinedGroups({
+    cache: cachedGroupsByModifiersAndSelectors,
+    selectors,
+    modifiers,
+  })
   let computedCustomGroup = computeGroup({
     customGroupMatcher: customGroup =>
       doesCustomGroupMatch({
@@ -429,11 +436,7 @@ function computeGroupExceptUnknown({ selectors, modifiers, options, name }) {
         modifiers,
         selectors,
       }),
-    predefinedGroups: generatePredefinedGroups({
-      cache: cachedGroupsByModifiersAndSelectors,
-      selectors,
-      modifiers,
-    }),
+    predefinedGroups,
     options,
   })
   if (computedCustomGroup === 'unknown') {
@@ -451,7 +454,7 @@ var styleExtensions = [
   '.sss',
 ]
 function isStyle(value) {
-  let [cleanedValue] = value.split('?')
+  let [cleanedValue] = value.split('?', 1)
   return styleExtensions.some(extension => cleanedValue?.endsWith(extension))
 }
 export { sort_imports_default as default }

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

@@ -52,16 +52,13 @@ function sortJsxObject({ matchedAstSelectors, context, node }) {
   }
   let { sourceCode, id } = context
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      sourceCode,
-      context,
-      node,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    sourceCode,
+    context,
+    node,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     selectors: allSelectors,
@@ -90,6 +87,11 @@ function sortJsxObject({ matchedAstSelectors, context, node }) {
         modifiers.push('multiline')
       }
       selectors.push('prop')
+      let predefinedGroups = generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors,
+        modifiers,
+      })
       let group = computeGroup({
         customGroupMatcher: customGroup =>
           doesCustomGroupMatch({
@@ -100,11 +102,7 @@ function sortJsxObject({ matchedAstSelectors, context, node }) {
             selectors,
             modifiers,
           }),
-        predefinedGroups: generatePredefinedGroups({
-          cache: cachedGroupsByModifiersAndSelectors,
-          selectors,
-          modifiers,
-        }),
+        predefinedGroups,
         options,
       })
       let sortingNode = {

package/dist/rules/sort-maps/sort-potential-map.js

@@ -53,15 +53,12 @@ function sortPotentialMap({ matchedAstSelectors, context, node }) {
   }
   let { sourceCode, id } = context
   let settings = getSettings(context.settings)
-  let options = complete(
-    computeMatchedContextOptions({
-      matchedAstSelectors,
-      elements,
-      context,
-    }),
-    settings,
-    defaultOptions,
-  )
+  let matchedContextOptions = computeMatchedContextOptions({
+    matchedAstSelectors,
+    elements,
+    context,
+  })
+  let options = complete(matchedContextOptions, settings, defaultOptions)
   validateCustomSortConfig(options)
   validateGroupsConfig({
     selectors: [],