eslint-interactive 12.0.0 → 13.0.1

package/src/cli/parse-argv.ts

@@ -1,46 +1,23 @@
 import { parseArgs } from 'node:util';
-import type { DeepPartial } from '../util/type-check.js';
+import type { Config, SortField, SortOrder } from '../type.js';
 import { VERSION } from './package.js';
 
-export type ParsedCLIOptions = {
-  patterns: string[];
-  formatterName: string | undefined;
-  quiet: boolean | undefined;
-  useEslintrc: boolean | undefined;
-  overrideConfigFile: string | undefined;
-  extensions: string[] | undefined;
-  rulePaths: string[] | undefined;
-  ignorePath: string | undefined;
-  cache: boolean | undefined;
-  cacheLocation: string | undefined;
-  resolvePluginsRelativeTo: string | undefined;
-  flags: string[] | undefined;
-};
-
-/** Default CLI Options */
-export const cliOptionsDefaults = {
-  formatterName: 'stylish',
-  quiet: false,
-  useEslintrc: true,
-  cache: false,
-} satisfies DeepPartial<ParsedCLIOptions>;
+const VALID_SORT_FIELDS: readonly SortField[] = ['rule', 'error', 'warning', 'fixable', 'suggestions'];
+const VALID_SORT_ORDERS: readonly SortOrder[] = ['asc', 'desc'];
 
 /** Parse CLI options */
-export function parseArgv(argv: string[]): ParsedCLIOptions {
+export function parseArgv(argv: string[]): Config {
   const options = {
-    'eslintrc': { type: 'boolean', default: cliOptionsDefaults.useEslintrc },
     'config': { type: 'string', short: 'c' },
-    'ext': { type: 'string', multiple: true },
-    'resolve-plugins-relative-to': { type: 'string' },
-    'rulesdir': { type: 'string', multiple: true },
-    'ignore-path': { type: 'string' },
-    'format': { type: 'string', default: cliOptionsDefaults.formatterName },
-    'quiet': { type: 'boolean', default: cliOptionsDefaults.quiet },
-    'cache': { type: 'boolean', default: cliOptionsDefaults.cache },
+    'format': { type: 'string' },
+    'quiet': { type: 'boolean' },
+    'cache': { type: 'boolean' },
     'cache-location': { type: 'string' },
     'version': { type: 'boolean' },
     'help': { type: 'boolean' },
     'flag': { type: 'string', multiple: true },
+    'sort': { type: 'string' },
+    'sort-order': { type: 'string' },
   } as const;
 
   const { values, positionals } = parseArgs({
@@ -51,6 +28,20 @@ export function parseArgv(argv: string[]): ParsedCLIOptions {
     options,
   });
 
+  // Validate `--sort` and `--sort-order`
+  if (values.sort !== undefined && !VALID_SORT_FIELDS.includes(values.sort as SortField)) {
+    console.error(`Invalid --sort value: "${values.sort}". Must be one of: ${VALID_SORT_FIELDS.join(', ')}`);
+    // eslint-disable-next-line n/no-process-exit
+    process.exit(1);
+  }
+  if (values['sort-order'] !== undefined && !VALID_SORT_ORDERS.includes(values['sort-order'] as SortOrder)) {
+    console.error(
+      `Invalid --sort-order value: "${values['sort-order']}". Must be one of: ${VALID_SORT_ORDERS.join(', ')}`,
+    );
+    // eslint-disable-next-line n/no-process-exit
+    process.exit(1);
+  }
+
   if (values.version) {
     console.log(VERSION);
     // eslint-disable-next-line n/no-process-exit
@@ -58,53 +49,46 @@ export function parseArgv(argv: string[]): ParsedCLIOptions {
   }
 
   if (values.help) {
-    console.log(`
-eslint-interactive [file.js] [dir]
+    console.log(
+      `
+eslint-interactive [...patterns]
 
 Options:
-      --help                         Show help                                                                                       [boolean]
-      --version                      Show version number                                                                             [boolean]
-      --eslintrc                     Enable use of configuration from .eslintrc.*                                    [boolean] [default: true]
-  -c, --config                       Use this configuration, overriding .eslintrc.* config options if present                         [string]
-      --resolve-plugins-relative-to  A folder where plugins should be resolved from, CWD by default                                   [string]
-      --ext                          Specify JavaScript file extensions                                                                [array]
-      --rulesdir                     Use additional rules from this directory                                                          [array]
-      --ignore-path                  Specify path of ignore file                                                                      [string]
-      --format                       Specify the format to be used for the \`Display problem messages\` action   [string] [default: "stylish"]
-      --quiet                        Report errors only                                                             [boolean] [default: false]
-      --cache                        Only check changed files                                                       [boolean] [default: false]
-      --cache-location               Path to the cache file or directory                                                              [string]
-      --flag                         Enable a feature flag (requires ESLint v9.6.0+)                                                   [array]
+      --help                   Show help
+      --version                Show version number
+  -c, --config <path>          Use this configuration, overriding config options if present
+      --format <nameOrPath>    Specify the format to be used for the "Display problem messages" action
+      --quiet                  Report errors only
+      --cache                  Only check changed files
+      --cache-location <path>  Path to the cache file or directory
+      --flag <name>            Enable a feature flag (requires ESLint v9.6.0+)
+      --sort <field>           Sort rules by: rule, error, warning, fixable, suggestions
+      --sort-order <direction> Sort direction: asc, desc (default: desc for counts, asc for rule)
 
 Examples:
-  eslint-interactive ./src                                           Lint ./src/ directory
-  eslint-interactive ./src ./test                                    Lint multiple directories
-  eslint-interactive './src/**/*.{ts,tsx,vue}'                       Lint with glob pattern
-  eslint-interactive ./src --ext .ts,.tsx,.vue                       Lint with custom extensions
-  eslint-interactive ./src --rulesdir ./rules                        Lint with custom rules
-  eslint-interactive ./src --no-eslintrc --config ./.eslintrc.ci.js  Lint with custom config
-      `);
+  eslint-interactive                          Lint all files in the project
+  eslint-interactive src test                 Lint specified directories
+  eslint-interactive 'src/**/*.{ts,tsx,vue}'  Lint with glob pattern
+  eslint-interactive --sort error             Sort rules by error count (descending)
+  eslint-interactive --sort rule              Sort rules by rule name (ascending)
+`.trim(),
+    );
     // eslint-disable-next-line n/no-process-exit
     process.exit(0);
   }
 
   const patterns = positionals.map((pattern) => pattern.toString());
-  const rulePaths = values.rulesdir?.map((rulePath) => rulePath.toString());
-  const extensions = values.ext?.map((extension) => extension.toString()).flatMap((extension) => extension.split(','));
   const formatterName = values.format;
 
   return {
     patterns,
     formatterName,
     quiet: values.quiet,
-    useEslintrc: values.eslintrc,
     overrideConfigFile: values.config,
-    extensions,
-    rulePaths,
-    ignorePath: values['ignore-path'],
     cache: values.cache,
     cacheLocation: values['cache-location'],
-    resolvePluginsRelativeTo: values['resolve-plugins-relative-to'],
     flags: values.flag,
+    sort: values.sort as SortField | undefined,
+    sortOrder: values['sort-order'] as SortOrder | undefined,
   };
 }

package/src/cli/prompt.ts

@@ -20,8 +20,7 @@ export type Action =
   | 'disablePerLine'
   | 'disablePerFile'
   | 'convertErrorToWarningPerFile'
-  | 'applySuggestions'
-  | 'makeFixableAndFix'
+  | 'relintAndReselectRules'
   | 'reselectRules';
 
 /**
@@ -78,9 +77,8 @@ export async function promptToInputAction(
   const foldedStatistics = ruleStatistics.reduce(
     (a, b) => ({
       isFixableCount: a.isFixableCount + b.isFixableCount,
-      hasSuggestionsCount: a.hasSuggestionsCount + b.hasSuggestionsCount,
     }),
-    { isFixableCount: 0, hasSuggestionsCount: 0 },
+    { isFixableCount: 0 },
   );
 
   const choices = [
@@ -89,16 +87,8 @@ export async function promptToInputAction(
     { name: 'disablePerLine', message: '🔧 Disable per line' },
     { name: 'disablePerFile', message: '🔧 Disable per file' },
     { name: 'convertErrorToWarningPerFile', message: '🔧 Convert error to warning per file' },
-    {
-      name: 'applySuggestions',
-      message: '🔧 Apply suggestions (experimental, for experts)',
-      disabled: foldedStatistics.hasSuggestionsCount === 0,
-    },
-    {
-      name: 'makeFixableAndFix',
-      message: '🔧 Make forcibly fixable and run `eslint --fix` (experimental, for experts)',
-    },
-    { name: 'reselectRules', message: '↩️  Reselect rules' },
+    { name: 'relintAndReselectRules', message: '↩️ Go back (with re-lint)' },
+    { name: 'reselectRules', message: '↩️ Go back' },
   ];
 
   const { action } = await prompt<{
@@ -199,37 +189,3 @@ export async function promptToInputWhatToDoNext(): Promise<NextStep> {
   ]);
   return nextStep;
 }
-
-/**
- * Ask the user if they want to reuse the filter script.
- * @returns If it reuses, `true`, if not, `false`.
- */
-export async function promptToInputReuseFilterScript(): Promise<boolean> {
-  const { reuseFilterScript } = await prompt<{ reuseFilterScript: boolean }>([
-    {
-      name: 'reuseFilterScript',
-      type: 'confirm',
-      message: 'Do you want to reuse a previously edited filter script?',
-      initial: true,
-      onCancel,
-    },
-  ]);
-  return reuseFilterScript;
-}
-
-/**
- * Ask the user if they want to reuse the script.
- * @returns If it reuses, `true`, if not, `false`.
- */
-export async function promptToInputReuseScript(): Promise<boolean> {
-  const { reuseScript } = await prompt<{ reuseScript: boolean }>([
-    {
-      name: 'reuseScript',
-      type: 'confirm',
-      message: 'Do you want to reuse a previously edited script?',
-      initial: true,
-      onCancel,
-    },
-  ]);
-  return reuseScript;
-}

package/src/cli/run.ts

@@ -3,13 +3,9 @@ import { fileURLToPath } from 'node:url';
 import { Worker } from 'node:worker_threads';
 import { wrap } from 'comlink';
 import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
-import isInstalledGlobally from 'is-installed-globally';
 import terminalLink from 'terminal-link';
-import { warn } from '../cli/log.js';
 import { parseArgv } from '../cli/parse-argv.js';
-import { translateCLIOptions } from '../config.js';
 import type { SerializableCore } from '../core-worker.js';
-import { shouldUseFlatConfig } from '../eslint/use-at-your-own-risk.js';
 import type { NextScene } from '../scene/index.js';
 import { checkResults, lint, selectAction, selectRuleIds } from '../scene/index.js';
 
@@ -21,30 +17,18 @@ export type Options = {
  * Run eslint-interactive.
  */
 export async function run(options: Options) {
-  if (isInstalledGlobally) {
-    warn(
-      'eslint-interactive is installed globally. ' +
-        'The globally installed eslint-interactive is not officially supported because some features do not work. ' +
-        'It is recommended to install eslint-interactive locally.',
-    );
-  }
-  const parsedCLIOptions = parseArgv(options.argv);
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  const usingFlatConfig = await shouldUseFlatConfig();
-  const config = translateCLIOptions(parsedCLIOptions, usingFlatConfig ? 'flat' : 'eslintrc');
+  const config = parseArgv(options.argv);
 
   // Directly executing the Core API will hog the main thread and halt the spinner.
   // So we wrap it with comlink and run it on the Worker.
   const worker = new Worker(join(dirname(fileURLToPath(import.meta.url)), '..', 'core-worker.js'), {
     env: {
-      ...process.env,
-      // NOTE:
-      // - `terminal-link` uses `supports-hyperlinks` and `supports-color` to determine if a terminal that supports hyperlinks is in use.
-      // - If the terminal does not support hyperlinks, it will fallback to not print the link.
-      // - However, due to the specifications of Node.js, the decision does not work well on worker_threads.
-      // - So here we use a special environment variable to force the printing mode to be switched.
-      // ref: https://github.com/chalk/supports-color/issues/97, https://github.com/nodejs/node/issues/26946
+      // In worker threads, stdin is recognized as noTTY. Therefore, `util.styleText` and `terminalLink` disable colors and links.
+      // To work around this, we use environment variables to force colors and links to be enabled.
+      // ref: https://github.com/nodejs/node/issues/26946
+      FORCE_COLOR: process.stdin.isTTY ? '1' : '0',
       FORCE_HYPERLINK: terminalLink.isSupported ? '1' : '0',
+      ...process.env,
     },
     // NOTE: Pass CLI options (--unhandled-rejections=strict, etc.) to the worker
     execArgv: process.execArgv,

package/src/core-worker.ts

@@ -1,10 +1,8 @@
 import { parentPort } from 'node:worker_threads';
 import { expose, proxy } from 'comlink';
 import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
-import type { ESLint } from 'eslint';
-import type { Config } from './config.js';
 import { Core } from './core.js';
-import type { FixableMaker, SuggestionFilter } from './fix/index.js';
+import type { Config } from './type.js';
 
 /**
  * @file This is a wrapper module for using the Core API with comlink.
@@ -29,6 +27,11 @@ export class SerializableCore {
   formatResultSummary(...args: Parameters<Core['formatResultSummary']>): ReturnType<Core['formatResultSummary']> {
     return this.core.formatResultSummary(...args);
   }
+  getSortedRuleIdsInResults(
+    ...args: Parameters<Core['getSortedRuleIdsInResults']>
+  ): ReturnType<Core['getSortedRuleIdsInResults']> {
+    return this.core.getSortedRuleIdsInResults(...args);
+  }
   async formatResultDetails(...args: Parameters<Core['formatResultDetails']>): ReturnType<Core['formatResultDetails']> {
     return this.core.formatResultDetails(...args);
   }
@@ -46,24 +49,6 @@ export class SerializableCore {
   ): ReturnType<Core['convertErrorToWarningPerFile']> {
     return proxy(await this.core.convertErrorToWarningPerFile(...args));
   }
-  async applySuggestions(
-    results: ESLint.LintResult[],
-    ruleIds: string[],
-    filterScript: string,
-  ): ReturnType<Core['applySuggestions']> {
-    // eslint-disable-next-line no-eval -- TODO: replace with a better solution
-    const filter = eval(filterScript) as SuggestionFilter;
-    return proxy(await this.core.applySuggestions(results, ruleIds, filter));
-  }
-  async makeFixableAndFix(
-    results: ESLint.LintResult[],
-    ruleIds: string[],
-    fixableMakerScript: string,
-  ): ReturnType<Core['makeFixableAndFix']> {
-    // eslint-disable-next-line no-eval -- TODO: replace with a better solution
-    const fixableMaker = eval(fixableMakerScript) as FixableMaker;
-    return proxy(await this.core.makeFixableAndFix(results, ruleIds, fixableMaker));
-  }
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/core.ts

@@ -1,9 +1,7 @@
 import { writeFile } from 'node:fs/promises';
-import type { ESLint, Rule } from 'eslint';
+import type { Rule } from 'eslint';
+import { ESLint } from 'eslint';
 import type { DescriptionPosition } from './cli/prompt.js';
-import type { Config, NormalizedConfig } from './config.js';
-import { normalizeConfig } from './config.js';
-import { FlatESLint, LegacyESLint } from './eslint/use-at-your-own-risk.js';
 import type { FixableMaker, FixContext, SuggestionFilter } from './fix/index.js';
 import {
   createFixToApplyAutoFixes,
@@ -14,8 +12,9 @@ import {
   createFixToMakeFixableAndFix,
   verifyAndFix,
 } from './fix/index.js';
-import { format } from './formatter/index.js';
+import { format, sortRuleStatistics, takeRuleStatistics } from './formatter/index.js';
 import { plugin } from './plugin.js';
+import type { Config, SortField, SortOrder } from './type.js';
 import { filterResultsByRuleId } from './util/eslint.js';
 
 /**
@@ -37,49 +36,41 @@ export type Undo = () => Promise<void>;
  * It uses ESLint's Node.js API to output a summary of problems, fix problems, apply suggestions, etc.
  */
 export class Core {
-  readonly config: NormalizedConfig;
-  readonly eslint: InstanceType<typeof FlatESLint> | InstanceType<typeof LegacyESLint>;
+  readonly #cwd: string;
+  readonly #patterns: string[];
+  readonly #quiet: boolean;
+  readonly #formatterName: string | undefined;
+  readonly #sort: SortField | undefined;
+  readonly #sortOrder: SortOrder | undefined;
+  readonly #eslint: ESLint;
 
   constructor(config: Config) {
-    this.config = normalizeConfig(config);
-    const eslintOptions = this.config.eslintOptions;
-    if (eslintOptions.type === 'eslintrc') {
-      const { type, ...rest } = eslintOptions;
-      this.eslint = new LegacyESLint({
-        ...rest,
-        plugins: {
-          ...rest.plugins,
-          'eslint-interactive': plugin,
-        },
-        overrideConfig: {
-          ...rest.overrideConfig,
-          plugins: [...(rest.overrideConfig?.plugins ?? []), 'eslint-interactive'],
+    this.#cwd = config.cwd ?? process.cwd();
+    this.#patterns = config.patterns;
+    this.#quiet = config.quiet ?? false;
+    this.#formatterName = config.formatterName;
+    this.#sort = config.sort;
+    this.#sortOrder = config.sortOrder;
+
+    // NOTE: Passing an option that does not exist to `new ESLint(...)` will throw an error.
+    // Therefore, only options supported by ESLint are extracted into the `eslintOptions` variable.
+    const { formatterName, patterns, quiet, sort, sortOrder, ...eslintOptions } = config;
+    const overrideConfigs =
+      Array.isArray(eslintOptions.overrideConfig) ? eslintOptions.overrideConfig
+      : eslintOptions.overrideConfig ? [eslintOptions.overrideConfig]
+      : [];
+    this.#eslint = new ESLint({
+      ...eslintOptions,
+      overrideConfig: [
+        ...overrideConfigs,
+        {
+          plugins: { 'eslint-interactive': plugin },
           rules: {
-            ...rest.overrideConfig?.rules,
             'eslint-interactive/source-code-snatcher': 'error',
           },
         },
-      });
-    } else {
-      const { type, ...rest } = eslintOptions;
-      const overrideConfigs =
-        Array.isArray(rest.overrideConfig) ? rest.overrideConfig
-        : rest.overrideConfig ? [rest.overrideConfig]
-        : [];
-      this.eslint = new FlatESLint({
-        ...rest,
-        overrideConfig: [
-          ...overrideConfigs,
-          {
-            ...rest.overrideConfig,
-            plugins: { 'eslint-interactive': plugin },
-            rules: {
-              'eslint-interactive/source-code-snatcher': 'error',
-            },
-          },
-        ],
-      });
-    }
+      ],
+    });
   }
 
   /**
@@ -87,8 +78,8 @@ export class Core {
    * @returns The results of linting
    */
   async lint(): Promise<ESLint.LintResult[]> {
-    let results = await this.eslint.lintFiles(this.config.patterns);
-    if (this.config.quiet) results = LegacyESLint.getErrorResults(results);
+    let results = await this.#eslint.lintFiles(this.#patterns);
+    if (this.#quiet) results = ESLint.getErrorResults(results);
     return results;
   }
 
@@ -97,8 +88,20 @@ export class Core {
    * @param results The lint results of the project to print summary
    */
   formatResultSummary(results: ESLint.LintResult[]): string {
-    const rulesMeta = this.eslint.getRulesMetaForResults(results);
-    return format(results, { rulesMeta, cwd: this.config.cwd });
+    const rulesMeta = this.#eslint.getRulesMetaForResults(results);
+    return format(results, { rulesMeta, cwd: this.#cwd }, { sort: this.#sort, sortOrder: this.#sortOrder });
+  }
+
+  /**
+   * Returns ruleIds from lint results, sorted according to the configured sort options.
+   * @param results The lint results of the project
+   */
+  getSortedRuleIdsInResults(results: ESLint.LintResult[]): string[] {
+    let ruleStatistics = takeRuleStatistics(results);
+    if (this.#sort) {
+      ruleStatistics = sortRuleStatistics(ruleStatistics, this.#sort, this.#sortOrder);
+    }
+    return ruleStatistics.map((s) => s.ruleId);
   }
 
   /**
@@ -107,8 +110,7 @@ export class Core {
    * @param ruleIds The rule ids to print details
    */
   async formatResultDetails(results: ESLint.LintResult[], ruleIds: (string | null)[]): Promise<string> {
-    const formatterName = this.config.formatterName;
-    const formatter = await this.eslint.loadFormatter(formatterName);
+    const formatter = await this.#eslint.loadFormatter(this.#formatterName);
     return formatter.format(filterResultsByRuleId(results, ruleIds));
   }
 
@@ -207,7 +209,7 @@ export class Core {
       if (!source) throw new Error('Source code is required to apply fixes.');
 
       // eslint-disable-next-line no-await-in-loop
-      const fixedResult = await verifyAndFix(this.eslint, source, filePath, ruleIds, fixCreator);
+      const fixedResult = await verifyAndFix(this.#eslint, source, filePath, ruleIds, fixCreator);
 
       // Write the fixed source code to the file
       if (fixedResult.fixed) {
@@ -218,7 +220,7 @@ export class Core {
 
     return async () => {
       const resultsToUndo = generateResultsToUndo(filteredResultsOfLint);
-      await LegacyESLint.outputFixes(resultsToUndo);
+      await ESLint.outputFixes(resultsToUndo);
     };
   }
 }

package/src/eslint/linter.ts

@@ -7,12 +7,11 @@
  * @author aladdin-add
  */
 
-import type { Rule } from 'eslint';
+import type { ESLint, Rule } from 'eslint';
 import type { FixContext } from '../fix/index.js';
 import { getLastSourceCode } from '../plugin.js';
 import { ruleFixer } from './rule-fixer.js';
 import { SourceCodeFixer } from './source-code-fixer.js';
-import type { FlatESLint, LegacyESLint } from './use-at-your-own-risk.js';
 
 const MAX_AUTOFIX_PASSES = 10;
 
@@ -27,7 +26,7 @@ type FixedResult = {
  */
 
 export async function verifyAndFix(
-  eslint: InstanceType<typeof FlatESLint> | InstanceType<typeof LegacyESLint>,
+  eslint: ESLint,
   text: string,
   filePath: string,
   ruleIds: string[],

package/src/fix/make-fixable-and-fix.ts

@@ -1,12 +1,9 @@
-import type { Linter, Rule, SourceCode } from 'eslint';
-import { traverse } from 'estraverse';
-import type { Node } from 'estree';
-import { unreachable } from '../util/type-check.js';
+import type { AST, Linter, Rule, SourceCode } from 'eslint';
 import type { FixContext } from './index.js';
 
 export type FixableMaker = (
   message: Linter.LintMessage,
-  node: Node | null,
+  range: AST.Range,
   context: FixContext,
 ) => Rule.Fix | null | undefined;
 
@@ -14,58 +11,29 @@ export type FixToMakeFixableAndFixArgs = {
   fixableMaker: FixableMaker;
 };
 
-/**
- * Check the node is the source of the message.
- */
-function isMessageSourceNode(sourceCode: SourceCode, node: Node, message: Linter.LintMessage): boolean {
-  // eslint-disable-next-line @typescript-eslint/no-deprecated -- TODO: Do not use `nodeType` in the future.
-  if (message.nodeType === undefined) return false;
-
-  // In some cases there may be no `endLine` or `endColumn`.
-  if (message.endLine === undefined || message.endColumn === undefined) return false;
-  // If `nodeType` is exists, `range` must be exists.
-  if (node.range === undefined) return unreachable();
-
+function getMessageRange(sourceCode: SourceCode, message: Linter.LintMessage): AST.Range {
   const index = sourceCode.getIndexFromLoc({
     line: message.line,
     // NOTE: `column` of `ESLint.LintMessage` is 1-based, but `column` of `ESTree.Position` is 0-based.
     column: message.column - 1,
   });
-  const endIndex = sourceCode.getIndexFromLoc({
-    line: message.endLine,
-    // NOTE: `column` of `ESLint.LintMessage` is 1-based, but `column` of `ESTree.Position` is 0-based.
-    column: message.endColumn - 1,
-  });
-  // eslint-disable-next-line @typescript-eslint/no-deprecated -- TODO: Do not use `nodeType` in the future.
-  const nodeType = message.nodeType;
-
-  return node.range[0] === index && node.range[1] === endIndex && node.type === nodeType;
-}
-
-function getMessageToSourceNode(sourceCode: SourceCode, messages: Linter.LintMessage[]): Map<Linter.LintMessage, Node> {
-  const result = new Map<Linter.LintMessage, Node>();
-
-  traverse(sourceCode.ast, {
-    // Required to traverse extension nodes such as `JSXElement`.
-    fallback: 'iteration',
-    enter(node: Node) {
-      for (const message of messages) {
-        if (isMessageSourceNode(sourceCode, node, message)) {
-          result.set(message, node);
-        }
-      }
-    },
-  });
-  return result;
+  if (message.endLine && message.endColumn) {
+    const endIndex = sourceCode.getIndexFromLoc({
+      line: message.endLine,
+      // NOTE: `column` of `ESLint.LintMessage` is 1-based, but `column` of `ESTree.Position` is 0-based.
+      column: message.endColumn - 1,
+    });
+    return [index, endIndex];
+  } else {
+    return [index, index];
+  }
 }
 
 function generateFixes(context: FixContext, args: FixToMakeFixableAndFixArgs): Rule.Fix[] {
-  const messageToNode = getMessageToSourceNode(context.sourceCode, context.messages);
-
   const fixes: Rule.Fix[] = [];
   for (const message of context.messages) {
-    const node = messageToNode.get(message) ?? null;
-    const fix = args.fixableMaker(message, node, context);
+    const range = getMessageRange(context.sourceCode, message);
+    const fix = args.fixableMaker(message, range, context);
     if (fix) fixes.push(fix);
   }
   return fixes;

package/src/formatter/format-by-files.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
 import { styleText } from 'node:util';
 import type { ESLint } from 'eslint';
 import { ERROR_COLOR, FAILED_COLOR, WARNING_COLOR } from './colors.js';

package/src/formatter/format-by-rules.ts

@@ -1,8 +1,11 @@
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
 import { styleText } from 'node:util';
 import type { ESLint } from 'eslint';
 import terminalLink from 'terminal-link';
+import type { SortField, SortOrder } from '../type.js';
 import { ERROR_COLOR } from './colors.js';
 import { formatTable } from './format-table.js';
+import { sortRuleStatistics } from './sort-rule-statistics.js';
 import { takeRuleStatistics } from './take-rule-statistics.js';
 
 const headerRow = ['Rule', 'Error', 'Warning', 'is fixable', 'has suggestions'];
@@ -15,14 +18,26 @@ type Row = [
   hasSuggestionsCount: string,
 ];
 
+export type FormatByRulesSortOptions = {
+  sort?: SortField | undefined;
+  sortOrder?: SortOrder | undefined;
+};
+
 function numCell(num: number): string {
   return num > 0 ? styleText([ERROR_COLOR, 'bold'], num.toString()) : num.toString();
 }
 
-export function formatByRules(results: ESLint.LintResult[], data?: ESLint.LintResultData): string {
-  const ruleStatistics = takeRuleStatistics(results);
-  const rows: Row[] = [];
+export function formatByRules(
+  results: ESLint.LintResult[],
+  data?: ESLint.LintResultData,
+  sortOptions?: FormatByRulesSortOptions,
+): string {
+  let ruleStatistics = takeRuleStatistics(results);
+  if (sortOptions?.sort) {
+    ruleStatistics = sortRuleStatistics(ruleStatistics, sortOptions.sort, sortOptions.sortOrder);
+  }
 
+  const rows: Row[] = [];
   ruleStatistics.forEach((ruleStatistic) => {
     const { ruleId, errorCount, warningCount, isFixableCount, hasSuggestionsCount } = ruleStatistic;
     const ruleMetaData = data?.rulesMeta[ruleId];