eslint-plugin-perfectionist 5.10.1 → 5.11.0

package/dist/package.json.js

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

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

@@ -1,7 +1,6 @@
 import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
-import { matches } from '../../utils/matches.js'
 import { computeDependenciesBySortingNode as computeDependenciesBySortingNode$1 } from '../../utils/compute-dependencies-by-sorting-node.js'
-import { computeParentNodesWithTypes } from '../../utils/compute-parent-nodes-with-types.js'
+import { isNodeInsideDeferredFunction } from '../../utils/is-node-inside-deferred-function.js'
 import { computeIdentifierNameDetails } from './compute-identifier-name-details.js'
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils'
 function computeDependenciesBySortingNode({
@@ -44,7 +43,14 @@ function computeIdentifierOrThisExpressionDependency({
   classElement,
   node,
 }) {
-  if (shouldIgnoreCallbackDependency()) {
+  if (
+    classElement.type !== AST_NODE_TYPES.StaticBlock &&
+    isNodeInsideDeferredFunction({
+      ignoreCallbackDependenciesPatterns,
+      maxParent: classElement,
+      node,
+    })
+  ) {
     return null
   }
   let { parent } = node
@@ -73,23 +79,6 @@ function computeIdentifierOrThisExpressionDependency({
         return null
     }
   }
-  function shouldIgnoreCallbackDependency() {
-    return computeParentNodesWithTypes({
-      allowedTypes: [AST_NODE_TYPES.CallExpression],
-      maxParent: classElement,
-      consecutiveOnly: false,
-      node,
-    }).some(shouldIgnoreCallExpression)
-    function shouldIgnoreCallExpression(callExpressionParent) {
-      return (
-        'name' in callExpressionParent.callee &&
-        matches(
-          callExpressionParent.callee.name,
-          ignoreCallbackDependenciesPatterns,
-        )
-      )
-    }
-  }
 }
 function computeThisExpressionDependenciesBySortingNode({
   ignoreCallbackDependenciesPatterns,
@@ -146,27 +135,6 @@ function buildAdditionalIdentifierDependenciesComputer({
     return dependency ? [dependency] : []
   }
 }
-function shouldIgnoreDependencyComputation(node) {
-  switch (node.type) {
-    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
-    case AST_NODE_TYPES.TSAbstractMethodDefinition:
-    case AST_NODE_TYPES.StaticBlock:
-      return false
-    case AST_NODE_TYPES.TSAbstractAccessorProperty:
-    case AST_NODE_TYPES.PropertyDefinition:
-    case AST_NODE_TYPES.AccessorProperty:
-      return (
-        node.value?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.value?.type === AST_NODE_TYPES.FunctionExpression
-      )
-    case AST_NODE_TYPES.MethodDefinition:
-    case AST_NODE_TYPES.TSIndexSignature:
-      return true
-    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
-    default:
-      throw new UnreachableCaseError(node)
-  }
-}
 function computeThisExpressionsInsideClassElement({
   classElement,
   sourceCode,
@@ -183,4 +151,21 @@ function computeThisExpressionsInsideClassElement({
     return token.type === AST_TOKEN_TYPES.Keyword && token.value === 'this'
   }
 }
+function shouldIgnoreDependencyComputation(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractAccessorProperty:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.AccessorProperty:
+    case AST_NODE_TYPES.StaticBlock:
+      return false
+    case AST_NODE_TYPES.MethodDefinition:
+    case AST_NODE_TYPES.TSIndexSignature:
+      return true
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node)
+  }
+}
 export { computeDependenciesBySortingNode }

package/dist/rules/sort-classes/types.d.ts

@@ -50,7 +50,7 @@ export type Options = Partial<
      */
     ignoreCallbackDependenciesPatterns: RegexOption
     /**
-     * Enables experimental dependency detection.
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
   } & AllCommonOptions<

package/dist/rules/sort-enums/types.d.ts

@@ -47,7 +47,7 @@ export type Options = Partial<
      */
     sortByValue: 'ifNumericEnum' | 'always' | 'never'
     /**
-     * Enables experimental dependency detection.
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
   } & AllCommonOptions<

package/dist/rules/sort-imports/compute-common-selectors.d.ts

@@ -1,4 +1,4 @@
-import { ReadClosestTsConfigByPathValue } from './read-closest-ts-config-by-path.js'
+import { ReadClosestTsConfigByPathValue } from '../../utils/tsconfig/read-closest-ts-config-by-path.js'
 import { RegexOption } from '../../types/common-options.js'
 import { Selector } from './types.js'
 /**

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

@@ -1,5 +1,5 @@
 import { matches } from '../../utils/matches.js'
-import { getTypescriptImport } from './get-typescript-import.js'
+import { getTypescriptImport } from '../../utils/tsconfig/get-typescript-import.js'
 import { matchesTsconfigPaths } from './matches-tsconfig-paths.js'
 import { builtinModules } from 'node:module'
 /**

package/dist/rules/sort-imports/matches-tsconfig-paths.d.ts

@@ -1,4 +1,4 @@
-import { ReadClosestTsConfigByPathValue } from './read-closest-ts-config-by-path.js'
+import { ReadClosestTsConfigByPathValue } from '../../utils/tsconfig/read-closest-ts-config-by-path.js'
 /**
  * Checks if an import matches any of the path mappings in tsconfig.json.
  *

package/dist/rules/sort-imports/types.d.ts

@@ -3,6 +3,7 @@ import { TSESTree } from '@typescript-eslint/types'
 import { SortingNodeWithDependencies } from '../../utils/sort-nodes-by-dependencies.js'
 import { RegexOption, TypeOption } from '../../types/common-options.js'
 import { AllCommonOptions } from '../../types/all-common-options.js'
+import { TsConfigOption } from '../../types/ts-config-option.js'
 /**
  * Configuration options for the sort-imports rule.
  *
@@ -12,22 +13,7 @@ import { AllCommonOptions } from '../../types/all-common-options.js'
 export type Options = Partial<
   {
     /**
-     * TypeScript configuration for resolving module paths. Enables path alias
-     * resolution based on tsconfig.json paths configuration.
-     */
-    tsconfig: {
-      /**
-       * Optional filename of the TypeScript config file. `@default`
-       * tsconfig.json'.
-       */
-      filename?: string
-      /**
-       * Root directory where to search for the TypeScript config file.
-       */
-      rootDir: string
-    }
-    /**
-     * Enables experimental dependency detection.
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
     /**
@@ -42,6 +28,11 @@ export type Options = Partial<
      * @default 'node'
      */
     environment: 'node' | 'bun'
+    /**
+     * TypeScript configuration for resolving module paths. Enables path alias
+     * resolution based on tsconfig.json paths configuration.
+     */
+    tsconfig: TsConfigOption
     /**
      * Controls whether side-effect imports should be sorted. When false,
      * side-effect imports remain in their original positions.

package/dist/rules/sort-imports.js

@@ -45,14 +45,15 @@ import {
   allSelectors,
 } from './sort-imports/types.js'
 import { isNonExternalReferenceTsImportEquals } from './sort-imports/is-non-external-reference-ts-import-equals.js'
+import { readClosestTsConfigByPath } from '../utils/tsconfig/read-closest-ts-config-by-path.js'
 import { comparatorByOptionsComputer } from './sort-imports/comparator-by-options-computer.js'
-import { readClosestTsConfigByPath } from './sort-imports/read-closest-ts-config-by-path.js'
 import { isSideEffectOnlyGroup } from './sort-imports/is-side-effect-only-group.js'
 import { validateSideEffectsConfig } from './sort-imports/validate-side-effects-config.js'
 import { computeSpecifierModifiers } from './sort-imports/compute-specifier-modifiers.js'
 import { getOptionsWithCleanGroups } from '../utils/get-options-with-clean-groups.js'
 import { computeCommonSelectors } from './sort-imports/compute-common-selectors.js'
 import { computeDependencyNames } from './sort-imports/compute-dependency-names.js'
+import { tsconfigJsonSchema } from '../utils/json-schemas/tsconfig-json-schema.js'
 import { computeSpecifierName } from './sort-imports/compute-specifier-name.js'
 import { computeDependencies } from './sort-imports/compute-dependencies.js'
 import { isSideEffectImport } from './sort-imports/is-side-effect-import.js'
@@ -269,21 +270,6 @@ var sort_imports_default = createEslintRule({
             allowedAdditionalTypeValues: [TYPE_IMPORT_FIRST_TYPE_OPTION],
             additionalSortProperties: additionalSortOptionsJsonSchema,
           }),
-          tsconfig: {
-            properties: {
-              rootDir: {
-                description: 'Specifies the tsConfig root directory.',
-                type: 'string',
-              },
-              filename: {
-                description: 'Specifies the tsConfig filename.',
-                type: 'string',
-              },
-            },
-            additionalProperties: false,
-            required: ['rootDir'],
-            type: 'object',
-          },
           maxLineLength: {
             description: 'Specifies the maximum line length.',
             exclusiveMinimum: true,
@@ -305,6 +291,7 @@ var sort_imports_default = createEslintRule({
           partitionByComment: partitionByCommentJsonSchema,
           partitionByNewLine: partitionByNewlineJsonSchema,
           internalPattern: buildRegexJsonSchema(),
+          tsconfig: tsconfigJsonSchema,
         },
         additionalProperties: false,
         type: 'object',

package/dist/rules/sort-modules/build-usage-comparator.js

@@ -2,7 +2,7 @@ import { populateSortingNodeGroupsWithDependencies } from '../../utils/populate-
 import { isNodeDependentOnOtherNode } from '../../utils/is-node-dependent-on-other-node.js'
 import { sortNodesByDependencies } from '../../utils/sort-nodes-by-dependencies.js'
 import { buildSortingNodeByNodeMap } from '../../utils/build-sorting-node-by-node-map.js'
-import { computeDependenciesBySortingNode } from './compute-dependencies-by-sorting-node.js'
+import { computeDependenciesBySortingNode } from './dependencies/compute-dependencies-by-sorting-node.js'
 import { computeDependencies } from './compute-dependencies.js'
 /**
  * Builds a comparator function for sorting module nodes based on their usage.

package/dist/rules/sort-modules/compute-additional-module-statements.d.ts

@@ -0,0 +1,19 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Computes the statement list of a node that must be analyzed as a module
+ * block.
+ *
+ * Some parsers wrap top-level code in a custom node instead of putting it
+ * directly in `Program.body`. Such a node can only be analyzed as a module
+ * block if it holds an array of statements in its `body` property.
+ *
+ * @param node - The AST node to compute the module block body of.
+ * @param additionalModuleBlockTypes - The node types to analyze as module
+ *   blocks.
+ * @returns The statements of the module block, or null if the node is not a
+ *   module block.
+ */
+export declare function computeAdditionalModuleStatements(
+  node: TSESTree.Node,
+  additionalModuleBlockTypes: string[],
+): TSESTree.ProgramStatement[] | null

package/dist/rules/sort-modules/compute-additional-module-statements.js

@@ -0,0 +1,32 @@
+var BUILT_IN_MODULE_BLOCK_TYPES = ['SvelteScriptElement']
+/**
+ * Computes the statement list of a node that must be analyzed as a module
+ * block.
+ *
+ * Some parsers wrap top-level code in a custom node instead of putting it
+ * directly in `Program.body`. Such a node can only be analyzed as a module
+ * block if it holds an array of statements in its `body` property.
+ *
+ * @param node - The AST node to compute the module block body of.
+ * @param additionalModuleBlockTypes - The node types to analyze as module
+ *   blocks.
+ * @returns The statements of the module block, or null if the node is not a
+ *   module block.
+ */
+function computeAdditionalModuleStatements(node, additionalModuleBlockTypes) {
+  if (
+    ![...BUILT_IN_MODULE_BLOCK_TYPES, ...additionalModuleBlockTypes].includes(
+      node.type,
+    )
+  ) {
+    return null
+  }
+  if (!('body' in node)) {
+    return null
+  }
+  if (!Array.isArray(node.body)) {
+    return null
+  }
+  return node.body
+}
+export { computeAdditionalModuleStatements }

package/dist/rules/sort-modules/dependencies/compute-dependencies-by-sorting-node.d.ts

@@ -0,0 +1,26 @@
+import { TSESLint } from '@typescript-eslint/utils'
+import { SortModulesSortingNodeWithoutDependencies } from './is-identifier-in-decorator-metadata-type-position.js'
+type HardDependencyDetectionParameters = {
+  emitDecoratorMetadata: boolean
+  dependencyDetection: 'hard'
+} & CommonParameters
+type SoftDependencyDetectionParameters = {
+  emitDecoratorMetadata?: never
+  dependencyDetection: 'soft'
+} & CommonParameters
+interface CommonParameters {
+  sortingNodes: SortModulesSortingNodeWithoutDependencies[]
+  sourceCode: TSESLint.SourceCode
+}
+type Parameters =
+  SoftDependencyDetectionParameters | HardDependencyDetectionParameters
+export declare function computeDependenciesBySortingNode({
+  emitDecoratorMetadata,
+  dependencyDetection,
+  sortingNodes,
+  sourceCode,
+}: Parameters): Map<
+  SortModulesSortingNodeWithoutDependencies,
+  SortModulesSortingNodeWithoutDependencies[]
+>
+export {}

package/dist/rules/sort-modules/{compute-dependencies-by-sorting-node.js → dependencies/compute-dependencies-by-sorting-node.js}

@@ -1,32 +1,56 @@
-import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
-import { computeDependenciesBySortingNode as computeDependenciesBySortingNode$1 } from '../../utils/compute-dependencies-by-sorting-node.js'
-import { computeParentNodesWithTypes } from '../../utils/compute-parent-nodes-with-types.js'
-import { doesSortingNodeHaveOneOfDependencyNames } from '../../utils/does-sorting-node-have-one-of-dependency-names.js'
-import { isPropertyOrAccessorNode } from './is-property-or-accessor-node.js'
-import { isArrowFunctionNode } from './is-arrow-function-node.js'
+import { UnreachableCaseError } from '../../../utils/unreachable-case-error.js'
+import { computeDependenciesBySortingNode as computeDependenciesBySortingNode$1 } from '../../../utils/compute-dependencies-by-sorting-node.js'
+import { computeParentNodesWithTypes } from '../../../utils/compute-parent-nodes-with-types.js'
+import { isIdentifierInDecoratorMetadataTypePosition } from './is-identifier-in-decorator-metadata-type-position.js'
+import { doesSortingNodeHaveOneOfDependencyNames } from '../../../utils/does-sorting-node-have-one-of-dependency-names.js'
+import { isPropertyOrAccessorNode } from '../is-property-or-accessor-node.js'
+import { isArrowFunctionNode } from '../is-arrow-function-node.js'
 import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 function computeDependenciesBySortingNode({
+  emitDecoratorMetadata,
   dependencyDetection,
   sortingNodes,
   sourceCode,
 }) {
   return computeDependenciesBySortingNode$1({
+    shouldIgnoreIdentifierComputer: buildShouldIgnoreIdentifierComputer({
+      emitDecoratorMetadata,
+      dependencyDetection,
+      sortingNodes,
+    }),
     additionalIdentifierDependenciesComputer:
       buildAdditionalIdentifierDependenciesComputer({ sortingNodes }),
     shouldIgnoreSortingNodeComputer:
       buildShouldIgnoreSortingNodeComputer(dependencyDetection),
-    shouldIgnoreIdentifierComputer:
-      buildShouldIgnoreIdentifierComputer(dependencyDetection),
     sortingNodes,
     sourceCode,
   })
 }
-function buildShouldIgnoreIdentifierComputer(dependencyDetection) {
+function buildShouldIgnoreIdentifierComputer({
+  emitDecoratorMetadata,
+  dependencyDetection,
+  sortingNodes,
+}) {
   return ({ referencingSortingNode, identifier }) => {
     switch (dependencyDetection) {
       case 'soft':
         return false
       case 'hard':
+        if (
+          emitDecoratorMetadata &&
+          isIdentifierInDecoratorMetadataTypePosition({
+            sortingNodes,
+            identifier,
+          })
+        ) {
+          return false
+        }
+        if (
+          identifier.parent.type === AST_NODE_TYPES.TSTypeReference &&
+          identifier.parent.typeName === identifier
+        ) {
+          return true
+        }
         return !isInRelevantClassContext()
       /* v8 ignore next 2 -- @preserve Exhaustive guard. */
       default:

package/dist/rules/sort-modules/dependencies/is-identifier-in-decorator-metadata-type-position.d.ts

@@ -0,0 +1,13 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { SortModulesSortingNode } from '../types.js'
+export type SortModulesSortingNodeWithoutDependencies = Omit<
+  SortModulesSortingNode,
+  'dependencies'
+>
+export declare function isIdentifierInDecoratorMetadataTypePosition({
+  sortingNodes,
+  identifier,
+}: {
+  sortingNodes: SortModulesSortingNodeWithoutDependencies[]
+  identifier: TSESTree.JSXIdentifier | TSESTree.Identifier
+}): boolean

package/dist/rules/sort-modules/dependencies/is-identifier-in-decorator-metadata-type-position.js

@@ -0,0 +1,100 @@
+import { UnreachableCaseError } from '../../../utils/unreachable-case-error.js'
+import { computeParentNodesWithTypes } from '../../../utils/compute-parent-nodes-with-types.js'
+import { getNodeDecorators } from '../../../utils/get-node-decorators.js'
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+function isIdentifierInDecoratorMetadataTypePosition({
+  sortingNodes,
+  identifier,
+}) {
+  let { parent } = identifier
+  if (
+    parent.type !== AST_NODE_TYPES.TSTypeReference ||
+    parent.typeName !== identifier
+  ) {
+    return false
+  }
+  if (isLocalNonClassReference(sortingNodes, identifier)) {
+    return false
+  }
+  let typeAnnotationHost = computeTypeAnnotationHost(parent)
+  if (!typeAnnotationHost) {
+    return false
+  }
+  switch (typeAnnotationHost.type) {
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.AccessorProperty:
+      return getNodeDecorators(typeAnnotationHost).length > 0
+    case AST_NODE_TYPES.FunctionExpression: {
+      let methodDefinition = typeAnnotationHost.parent
+      if (methodDefinition.type !== AST_NODE_TYPES.MethodDefinition) {
+        return false
+      }
+      if (methodDefinition.kind === 'set') {
+        return getNodeDecorators(methodDefinition).length > 0
+      }
+      if (
+        methodDefinition.value.params.some(
+          parameter => getNodeDecorators(parameter).length > 0,
+        )
+      ) {
+        return true
+      }
+      switch (methodDefinition.kind) {
+        case 'constructor':
+          return getNodeDecorators(methodDefinition.parent.parent).length > 0
+        case 'method':
+        case 'get':
+          return getNodeDecorators(methodDefinition).length > 0
+        /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+        default:
+          throw new UnreachableCaseError(methodDefinition.kind)
+      }
+    }
+    default:
+      return false
+  }
+}
+function computeTypeAnnotationHost(typeReference) {
+  let annotation = typeReference.parent
+  if (
+    annotation.type === AST_NODE_TYPES.TSArrayType &&
+    annotation.parent.type === AST_NODE_TYPES.TSTypeAnnotation &&
+    annotation.parent.parent.type === AST_NODE_TYPES.RestElement
+  ) {
+    annotation = annotation.parent
+  }
+  if (annotation.type !== AST_NODE_TYPES.TSTypeAnnotation) {
+    return null
+  }
+  return (
+    computeParentNodesWithTypes({
+      allowedTypes: [
+        AST_NODE_TYPES.Identifier,
+        AST_NODE_TYPES.ObjectPattern,
+        AST_NODE_TYPES.ArrayPattern,
+        AST_NODE_TYPES.RestElement,
+        AST_NODE_TYPES.AssignmentPattern,
+        AST_NODE_TYPES.TSParameterProperty,
+      ],
+      consecutiveOnly: true,
+      node: annotation,
+      maxParent: null,
+    }).at(-1)?.parent ?? annotation.parent
+  )
+}
+function isLocalNonClassReference(sortingNodes, identifier) {
+  let matchingSortingNode = sortingNodes.find(
+    sortingNode => sortingNode.name === identifier.name,
+  )
+  if (!matchingSortingNode) {
+    return false
+  }
+  return (
+    (matchingSortingNode.node.type === AST_NODE_TYPES.ExportNamedDeclaration ?
+      matchingSortingNode.node.declaration
+    : matchingSortingNode.node
+    )?.type !== AST_NODE_TYPES.ClassDeclaration
+  )
+}
+export { isIdentifierInDecoratorMetadataTypePosition }

package/dist/rules/sort-modules/types.d.ts

@@ -4,6 +4,7 @@ import { SortingNodeWithDependencies } from '../../utils/sort-nodes-by-dependenc
 import { NewlinesBetweenOption } from '../../types/common-groups-options.js'
 import { RegexOption, TypeOption } from '../../types/common-options.js'
 import { AllCommonOptions } from '../../types/all-common-options.js'
+import { TsConfigOption } from '../../types/ts-config-option.js'
 /**
  * Configuration options for the sort-modules rule.
  *
@@ -19,9 +20,20 @@ export type Options = [
        */
       newlinesBetweenOverloadSignatures: NewlinesBetweenOption
       /**
-       * Enables experimental dependency detection.
+       * @deprecated Enables experimental dependency detection.
        */
       useExperimentalDependencyDetection: boolean
+      /**
+       * Node types to analyze as module blocks, in addition to the built-in
+       * ones. Lets parsers that wrap top-level code in a custom node be
+       * supported.
+       */
+      additionalModuleBlockTypes: string[]
+      /**
+       * TypeScript configuration used to read compiler options such as
+       * `emitDecoratorMetadata`.
+       */
+      tsconfig: TsConfigOption
     } & AllCommonOptions<
       CustomTypeOption,
       AdditionalSortOptions,

package/dist/rules/sort-modules.js

@@ -40,13 +40,16 @@ import { getDecoratorName } from '../utils/get-decorator-name.js'
 import { buildOverloadSignatureNewlinesBetweenValueGetter } from '../utils/overload-signature/build-overload-signature-newlines-between-value-getter.js'
 import { populateSortingNodeGroupsWithOverloadSignature } from '../utils/overload-signature/populate-sorting-node-groups-with-overload-signature.js'
 import '../utils/assert-is-never.js'
+import { readClosestTsConfigByPath } from '../utils/tsconfig/read-closest-ts-config-by-path.js'
+import { tsconfigJsonSchema } from '../utils/json-schemas/tsconfig-json-schema.js'
 import {
   USAGE_TYPE_OPTION,
   additionalCustomGroupMatchOptionsJsonSchema,
   allModifiers,
   allSelectors,
 } from './sort-modules/types.js'
-import { computeDependenciesBySortingNode } from './sort-modules/compute-dependencies-by-sorting-node.js'
+import { computeDependenciesBySortingNode } from './sort-modules/dependencies/compute-dependencies-by-sorting-node.js'
+import { computeAdditionalModuleStatements } from './sort-modules/compute-additional-module-statements.js'
 import { buildComparatorByOptionsComputer } from './sort-modules/build-comparator-by-options-computer.js'
 import { computeOverloadSignatureGroups } from './sort-modules/compute-overload-signature-groups.js'
 import { computeNodeDetails } from './sort-modules/compute-node-details.js'
@@ -79,6 +82,8 @@ var defaultOptions = {
   newlinesBetweenOverloadSignatures: 0,
   fallbackSort: { type: 'unsorted' },
   newlinesInside: 'newlinesBetween',
+  additionalModuleBlockTypes: [],
+  tsconfig: { rootDir: '' },
   partitionByComment: false,
   partitionByNewLine: false,
   newlinesBetween: 'ignore',
@@ -103,11 +108,18 @@ var sort_modules_default = createEslintRule({
               additionalCustomGroupMatchOptionsJsonSchema,
             allowedAdditionalTypeValues: [USAGE_TYPE_OPTION],
           }),
+          additionalModuleBlockTypes: {
+            description:
+              'Specifies the node types to analyze as module blocks, in addition to the built-in ones.',
+            items: { type: 'string' },
+            type: 'array',
+          },
           useExperimentalDependencyDetection:
             useExperimentalDependencyDetectionJsonSchema,
           newlinesBetweenOverloadSignatures: newlinesBetweenJsonSchema,
           partitionByComment: partitionByCommentJsonSchema,
           partitionByNewLine: partitionByNewlineJsonSchema,
+          tsconfig: tsconfigJsonSchema,
         },
         additionalProperties: false,
         type: 'object',
@@ -171,6 +183,21 @@ function analyzeModule({
     )
   let sortingNodeGroupsWithoutOverloadSignature = [[]]
   for (let node of module.body) {
+    let additionalModuleStatements = computeAdditionalModuleStatements(
+      node,
+      options.additionalModuleBlockTypes,
+    )
+    if (additionalModuleStatements) {
+      sortingNodeGroupsWithoutOverloadSignature.push([])
+      analyzeModule({
+        module: { body: additionalModuleStatements },
+        eslintDisabledLines,
+        sourceCode,
+        options,
+        context,
+      })
+      continue
+    }
     switch (node.type) {
       case AST_NODE_TYPES.TSNamespaceExportDeclaration:
       case AST_NODE_TYPES.ExportAllDeclaration:
@@ -304,7 +331,18 @@ function analyzeModule({
     overloadSignatureGroups,
   })
   if (options.useExperimentalDependencyDetection) {
+    let tsConfigOutput =
+      options.tsconfig.rootDir ?
+        readClosestTsConfigByPath({
+          tsconfigFilename: options.tsconfig.filename ?? 'tsconfig.json',
+          tsconfigRootDir: options.tsconfig.rootDir,
+          filePath: context.physicalFilename,
+          contextCwd: context.cwd,
+        })
+      : null
     let dependenciesBySortingNode = computeDependenciesBySortingNode({
+      emitDecoratorMetadata:
+        tsConfigOutput?.compilerOptions.emitDecoratorMetadata ?? false,
       sortingNodes: sortingNodeGroups.flat(),
       dependencyDetection: 'hard',
       sourceCode,

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

@@ -1,4 +1,4 @@
-import { computeDependenciesOutsideFunctionsBySortingNode } from '../../utils/compute-dependencies-outside-functions-by-sorting-node.js'
+import { computeDependenciesOutsideDeferredFunctionsBySortingNode } from '../../utils/compute-dependencies-outside-deferred-functions-by-sorting-node.js'
 import { populateSortingNodeGroupsWithDependencies } from '../../utils/populate-sorting-node-groups-with-dependencies.js'
 import { validateNewlinesAndPartitionConfig } from '../../utils/validate-newlines-and-partition-config.js'
 import { buildOptionsByGroupIndexComputer } from '../../utils/build-options-by-group-index-computer.js'
@@ -41,6 +41,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 var cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 var defaultOptions = {
   useExperimentalDependencyDetection: true,
+  ignoreCallbackDependenciesPatterns: [],
   fallbackSort: { type: 'unsorted' },
   newlinesInside: 'newlinesBetween',
   partitionByComputedKey: false,
@@ -181,7 +182,9 @@ function sortObject({ matchedAstSelectors, context, node }) {
   }
   if (options.useExperimentalDependencyDetection) {
     let dependenciesBySortingNode =
-      computeDependenciesOutsideFunctionsBySortingNode({
+      computeDependenciesOutsideDeferredFunctionsBySortingNode({
+        ignoreCallbackDependenciesPatterns:
+          options.ignoreCallbackDependenciesPatterns,
         sortingNodes: sortingNodeGroups.flat(),
         sourceCode,
       })

package/dist/rules/sort-objects/types.d.ts

@@ -69,7 +69,12 @@ export type Options = Partial<
       matchesAstSelector?: string
     }
     /**
-     * Enables experimental dependency detection.
+     * Regex patterns for function names whose callback argument dependencies
+     * should be ignored.
+     */
+    ignoreCallbackDependenciesPatterns: RegexOption
+    /**
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
     /**

package/dist/rules/sort-objects.js

@@ -1,5 +1,6 @@
 import {
   buildCommonJsonSchemas,
+  buildRegexJsonSchema,
   buildUseConfigIfJsonSchema,
   matchesAstSelectorJsonSchema,
   useExperimentalDependencyDetectionJsonSchema,
@@ -73,6 +74,7 @@ var sort_objects_default = createEslintRule({
           },
           useExperimentalDependencyDetection:
             useExperimentalDependencyDetectionJsonSchema,
+          ignoreCallbackDependenciesPatterns: buildRegexJsonSchema(),
           partitionByComment: partitionByCommentJsonSchema,
           partitionByNewLine: partitionByNewlineJsonSchema,
         },

package/dist/rules/sort-variable-declarations/sort-variable-declaration.js

@@ -6,7 +6,7 @@ import {
   ORDER_ERROR_ID,
   allSelectors,
 } from './types.js'
-import { computeDependenciesOutsideFunctionsBySortingNode } from '../../utils/compute-dependencies-outside-functions-by-sorting-node.js'
+import { computeDependenciesOutsideDeferredFunctionsBySortingNode } from '../../utils/compute-dependencies-outside-deferred-functions-by-sorting-node.js'
 import { populateSortingNodeGroupsWithDependencies } from '../../utils/populate-sorting-node-groups-with-dependencies.js'
 import { defaultComparatorByOptionsComputer } from '../../utils/compare/default-comparator-by-options-computer.js'
 import { validateNewlinesAndPartitionConfig } from '../../utils/validate-newlines-and-partition-config.js'
@@ -35,6 +35,7 @@ import { complete } from '../../utils/complete.js'
 var cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 var defaultOptions = {
   useExperimentalDependencyDetection: true,
+  ignoreCallbackDependenciesPatterns: [],
   fallbackSort: { type: 'unsorted' },
   newlinesInside: 'newlinesBetween',
   specialCharacters: 'keep',
@@ -133,7 +134,9 @@ function sortVariableDeclaration({ matchedAstSelectors, context, node }) {
   )
   if (options.useExperimentalDependencyDetection) {
     let dependenciesBySortingNode =
-      computeDependenciesOutsideFunctionsBySortingNode({
+      computeDependenciesOutsideDeferredFunctionsBySortingNode({
+        ignoreCallbackDependenciesPatterns:
+          options.ignoreCallbackDependenciesPatterns,
         sortingNodes: sortingNodeGroups.flat(),
         sourceCode,
       })

package/dist/rules/sort-variable-declarations/types.d.ts

@@ -41,7 +41,12 @@ export type Options = Partial<
       matchesAstSelector?: string
     }
     /**
-     * Enables experimental dependency detection.
+     * Regex patterns for function names whose callback argument dependencies
+     * should be ignored.
+     */
+    ignoreCallbackDependenciesPatterns: RegexOption
+    /**
+     * @deprecated Enables experimental dependency detection.
      */
     useExperimentalDependencyDetection: boolean
   } & AllCommonOptions<

package/dist/rules/sort-variable-declarations.js

@@ -1,5 +1,6 @@
 import {
   buildCommonJsonSchemas,
+  buildRegexJsonSchema,
   buildUseConfigIfJsonSchema,
   matchesAstSelectorJsonSchema,
   useExperimentalDependencyDetectionJsonSchema,
@@ -48,6 +49,7 @@ var sort_variable_declarations_default = createEslintRule({
           }),
           useExperimentalDependencyDetection:
             useExperimentalDependencyDetectionJsonSchema,
+          ignoreCallbackDependenciesPatterns: buildRegexJsonSchema(),
           partitionByComment: partitionByCommentJsonSchema,
           partitionByNewLine: partitionByNewlineJsonSchema,
         },

package/dist/types/ts-config-option.d.ts

@@ -0,0 +1,10 @@
+export interface TsConfigOption {
+  /**
+   * Optional filename of the TypeScript config file.
+   */
+  filename?: string
+  /**
+   * Root directory where to search for the TypeScript config file.
+   */
+  rootDir: string
+}

package/dist/utils/{compute-dependencies-outside-functions-by-sorting-node.d.ts → compute-dependencies-outside-deferred-functions-by-sorting-node.d.ts}

@@ -1,13 +1,16 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
 import { SortingNodeWithDependencies } from './sort-nodes-by-dependencies.js'
-export declare function computeDependenciesOutsideFunctionsBySortingNode<
+import { RegexOption } from '../types/common-options.js'
+export declare function computeDependenciesOutsideDeferredFunctionsBySortingNode<
   Node extends TSESTree.Node,
   T extends Pick<SortingNodeWithDependencies<Node>, 'dependencyNames' | 'node'>,
 >({
+  ignoreCallbackDependenciesPatterns,
   sortingNodes,
   sourceCode,
 }: {
+  ignoreCallbackDependenciesPatterns: RegexOption
   sourceCode: TSESLint.SourceCode
   sortingNodes: T[]
 }): Map<T, T[]>

package/dist/utils/compute-dependencies-outside-deferred-functions-by-sorting-node.js

@@ -0,0 +1,22 @@
+import { computeDependenciesBySortingNode } from './compute-dependencies-by-sorting-node.js'
+import { isNodeInsideDeferredFunction } from './is-node-inside-deferred-function.js'
+function computeDependenciesOutsideDeferredFunctionsBySortingNode({
+  ignoreCallbackDependenciesPatterns,
+  sortingNodes,
+  sourceCode,
+}) {
+  return computeDependenciesBySortingNode({
+    shouldIgnoreIdentifierComputer: buildShouldIgnoreIdentifierComputer(),
+    sortingNodes,
+    sourceCode,
+  })
+  function buildShouldIgnoreIdentifierComputer() {
+    return ({ referencingSortingNode, identifier }) =>
+      isNodeInsideDeferredFunction({
+        maxParent: referencingSortingNode.node,
+        ignoreCallbackDependenciesPatterns,
+        node: identifier,
+      })
+  }
+}
+export { computeDependenciesOutsideDeferredFunctionsBySortingNode }

package/dist/utils/get-settings.d.ts

@@ -1,6 +1,7 @@
 import { TSESLint } from '@typescript-eslint/utils'
 import { CommonPartitionOptions } from '../types/common-partition-options.js'
 import { CommonGroupsOptions } from '../types/common-groups-options.js'
+import { TsConfigOption } from '../types/ts-config-option.js'
 import { CommonOptions } from '../types/common-options.js'
 /**
  * Global settings for the Perfectionist plugin.
@@ -13,8 +14,9 @@ export type Settings = Partial<
   Pick<
     CommonGroupsOptions<string, unknown, unknown>,
     'newlinesBetween' | 'newlinesInside'
-  > &
-    CommonPartitionOptions &
+  > & {
+    tsconfig: TsConfigOption
+  } & CommonPartitionOptions &
     CommonOptions
 >
 /**

package/dist/utils/get-settings.js

@@ -53,6 +53,7 @@ function getSettings(settings) {
       'newlinesInside',
       'fallbackSort',
       'ignoreCase',
+      'tsconfig',
       'alphabet',
       'locales',
       'order',

package/dist/utils/is-node-immediately-called.d.ts

@@ -10,5 +10,8 @@ import { TSESTree } from '@typescript-eslint/types'
  * @returns Whether the node is immediately called.
  */
 export declare function isNodeImmediatelyCalled(
-  node: TSESTree.Expression,
+  node:
+    | TSESTree.ArrowFunctionExpression
+    | TSESTree.FunctionDeclaration
+    | TSESTree.FunctionExpression,
 ): boolean

package/dist/utils/is-node-inside-deferred-function.d.ts

@@ -0,0 +1,26 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { RegexOption } from '../types/common-options.js'
+/**
+ * Checks whether a node sits inside a function body that is deferred.
+ *
+ * Used to distinguish between references that are evaluated immediately (like
+ * IIFEs or synchronous callbacks) and those whose execution is delayed (like
+ * assigned functions or explicitly ignored callback wrappers).
+ *
+ * @param params - The parameters object.
+ * @param params.ignoreCallbackDependenciesPatterns - Optional regex pattern to
+ *   explicitly treat matching callback wrappers as deferred.
+ * @param params.maxParent - Maximum exclusive parent node to stop the search
+ *   at.
+ * @param params.node - The AST node whose enclosing functions are inspected.
+ * @returns Whether the node lives inside a deferred function.
+ */
+export declare function isNodeInsideDeferredFunction({
+  ignoreCallbackDependenciesPatterns,
+  maxParent,
+  node,
+}: {
+  ignoreCallbackDependenciesPatterns: RegexOption
+  maxParent: TSESTree.Node
+  node: TSESTree.Node
+}): boolean

package/dist/utils/is-node-inside-deferred-function.js

@@ -0,0 +1,70 @@
+import { matches } from './matches.js'
+import { computeParentNodesWithTypes } from './compute-parent-nodes-with-types.js'
+import { isNodeImmediatelyCalled } from './is-node-immediately-called.js'
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+/**
+ * Checks whether a node sits inside a function body that is deferred.
+ *
+ * Used to distinguish between references that are evaluated immediately (like
+ * IIFEs or synchronous callbacks) and those whose execution is delayed (like
+ * assigned functions or explicitly ignored callback wrappers).
+ *
+ * @param params - The parameters object.
+ * @param params.ignoreCallbackDependenciesPatterns - Optional regex pattern to
+ *   explicitly treat matching callback wrappers as deferred.
+ * @param params.maxParent - Maximum exclusive parent node to stop the search
+ *   at.
+ * @param params.node - The AST node whose enclosing functions are inspected.
+ * @returns Whether the node lives inside a deferred function.
+ */
+function isNodeInsideDeferredFunction({
+  ignoreCallbackDependenciesPatterns,
+  maxParent,
+  node,
+}) {
+  if (
+    ignoreCallbackDependenciesPatterns &&
+    matchesIgnoreCallbackDependencyPattern({
+      ignoreCallbackDependenciesPatterns,
+      maxParent,
+      node,
+    })
+  ) {
+    return true
+  }
+  return computeParentNodesWithTypes({
+    allowedTypes: [
+      AST_NODE_TYPES.FunctionExpression,
+      AST_NODE_TYPES.ArrowFunctionExpression,
+    ],
+    consecutiveOnly: false,
+    maxParent,
+    node,
+  }).some(isFunctionDeferred)
+}
+function matchesIgnoreCallbackDependencyPattern({
+  ignoreCallbackDependenciesPatterns,
+  maxParent,
+  node,
+}) {
+  return computeParentNodesWithTypes({
+    allowedTypes: [AST_NODE_TYPES.CallExpression],
+    consecutiveOnly: false,
+    maxParent,
+    node,
+  }).some(callExpressionMatchesCallbackDependencyPattern)
+  function callExpressionMatchesCallbackDependencyPattern(callExpression) {
+    return (
+      'name' in callExpression.callee &&
+      matches(callExpression.callee.name, ignoreCallbackDependenciesPatterns)
+    )
+  }
+}
+function isFunctionDeferred(functionNode) {
+  let { parent } = functionNode
+  if (isNodeImmediatelyCalled(functionNode)) {
+    return false
+  }
+  return parent.type !== AST_NODE_TYPES.CallExpression
+}
+export { isNodeInsideDeferredFunction }

package/dist/utils/json-schemas/tsconfig-json-schema.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
+export declare let tsconfigJsonSchema: JSONSchema4

package/dist/utils/json-schemas/tsconfig-json-schema.js

@@ -0,0 +1,16 @@
+var tsconfigJsonSchema = {
+  properties: {
+    rootDir: {
+      description: 'Specifies the tsConfig root directory.',
+      type: 'string',
+    },
+    filename: {
+      description: 'Specifies the tsConfig filename.',
+      type: 'string',
+    },
+  },
+  additionalProperties: false,
+  required: ['rootDir'],
+  type: 'object',
+}
+export { tsconfigJsonSchema }

package/dist/{rules/sort-imports → utils/tsconfig}/read-closest-ts-config-by-path.js

@@ -1,6 +1,12 @@
 import { getTypescriptImport } from './get-typescript-import.js'
 import * as path from 'node:path'
 import * as fs from 'node:fs'
+/**
+ * Diagnostics that don't affect compiler options resolution. They only concern
+ * the list of input files, which is irrelevant here, and are commonly emitted
+ * for empty or solution-style tsconfig files.
+ */
+var IGNORED_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([18002, 18003])
 /**
  * Cache mapping directories to their nearest tsconfig file path. Speeds up
  * config resolution for files in the same directory.
@@ -88,9 +94,12 @@ function getCompilerOptions(typescriptImport, contextCwd, filePath) {
     typescriptImport.sys,
     path.dirname(filePath),
   )
-  if (parsedContent.errors.length > 0) {
+  let fatalErrors = parsedContent.errors.filter(
+    error => !IGNORED_DIAGNOSTIC_CODES.has(error.code),
+  )
+  if (fatalErrors.length > 0) {
     throw new Error(
-      `Error getting compiler options: ${JSON.stringify(parsedContent.errors)}`,
+      `Error getting compiler options: ${JSON.stringify(fatalErrors)}`,
     )
   }
   let cache = typescriptImport.createModuleResolutionCache(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-perfectionist",
-  "version": "5.10.1",
+  "version": "5.11.0",
   "description": "ESLint plugin for sorting various data such as objects, imports, types, enums, JSX props, etc.",
   "keywords": [
     "eslint",
@@ -29,7 +29,7 @@
     "./dist"
   ],
   "dependencies": {
-    "@typescript-eslint/utils": "^8.65.0",
+    "@typescript-eslint/utils": "^8.68.0",
     "natural-orderby": "^5.0.0"
   },
   "peerDependencies": {

package/dist/rules/sort-modules/compute-dependencies-by-sorting-node.d.ts

@@ -1,16 +0,0 @@
-import { TSESLint } from '@typescript-eslint/utils'
-import { SortModulesSortingNode, DependencyDetection } from './types.js'
-type SortingNodeWithoutDependencies = Omit<
-  SortModulesSortingNode,
-  'dependencies'
->
-export declare function computeDependenciesBySortingNode({
-  dependencyDetection,
-  sortingNodes,
-  sourceCode,
-}: {
-  sortingNodes: SortingNodeWithoutDependencies[]
-  dependencyDetection: DependencyDetection
-  sourceCode: TSESLint.SourceCode
-}): Map<SortingNodeWithoutDependencies, SortingNodeWithoutDependencies[]>
-export {}

package/dist/utils/compute-dependencies-outside-functions-by-sorting-node.js

@@ -1,30 +0,0 @@
-import { computeDependenciesBySortingNode } from './compute-dependencies-by-sorting-node.js'
-import { computeParentNodesWithTypes } from './compute-parent-nodes-with-types.js'
-import { isNodeImmediatelyCalled } from './is-node-immediately-called.js'
-import { AST_NODE_TYPES } from '@typescript-eslint/utils'
-function computeDependenciesOutsideFunctionsBySortingNode({
-  sortingNodes,
-  sourceCode,
-}) {
-  return computeDependenciesBySortingNode({
-    shouldIgnoreIdentifierComputer: buildShouldIgnoreIdentifierComputer(),
-    sortingNodes,
-    sourceCode,
-  })
-  function buildShouldIgnoreIdentifierComputer() {
-    return ({ referencingSortingNode, identifier }) => {
-      return computeParentNodesWithTypes({
-        allowedTypes: [
-          AST_NODE_TYPES.FunctionExpression,
-          AST_NODE_TYPES.ArrowFunctionExpression,
-        ],
-        maxParent: referencingSortingNode.node,
-        consecutiveOnly: false,
-        node: identifier,
-      }).some(
-        functionParentNode => !isNodeImmediatelyCalled(functionParentNode),
-      )
-    }
-  }
-}
-export { computeDependenciesOutsideFunctionsBySortingNode }