eslint-interactive 8.1.0

package/src/core.ts

@@ -0,0 +1,240 @@
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { ESLint } from 'eslint';
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+import isInstalledGlobally = require('is-installed-globally');
+import { format } from './formatter/index.js';
+import {
+  eslintInteractivePlugin,
+  FixRuleOption,
+  FixableMaker,
+  SuggestionFilter,
+  Fix,
+  OVERLAPPED_PROBLEM_MESSAGE,
+} from './plugin/index.js';
+import { unique } from './util/array.js';
+import { getCacheDir } from './util/cache.js';
+import { filterResultsByRuleId, scanUsedPluginsFromResults } from './util/eslint.js';
+
+const MAX_AUTOFIX_PASSES = 10;
+
+/**
+ * Generate results to undo.
+ * @param resultsOfLint The results of lint.
+ * @returns The results to undo.
+ */
+function generateResultsToUndo(resultsOfLint: ESLint.LintResult[]): ESLint.LintResult[] {
+  return resultsOfLint.map((resultOfLint) => {
+    // NOTE: THIS IS HACK.
+    return { ...resultOfLint, output: resultOfLint.source };
+  });
+}
+
+function hasOverlappedProblems(results: ESLint.LintResult[]): boolean {
+  return results.flatMap((result) => result.messages).some((message) => message.message === OVERLAPPED_PROBLEM_MESSAGE);
+}
+
+/**
+ * Get all the rules loaded from eslintrc.
+ * @param targetFilePaths The target file paths.
+ * @param options The eslint option.
+ * @returns The rule ids loaded from eslintrc.
+ */
+async function getUsedRuleIds(targetFilePaths: string[], options: ESLint.Options): Promise<string[]> {
+  const eslintToGetRules = new ESLint(options);
+  const configs = await Promise.all(
+    targetFilePaths.map(async (filePath) => eslintToGetRules.calculateConfigForFile(filePath)),
+  );
+  return unique(configs.map((config) => config.rules).flatMap((rules) => Object.keys(rules)));
+}
+
+export type Undo = () => Promise<void>;
+
+/** The config of eslint-interactive */
+export type Config = {
+  patterns: string[];
+  rulePaths?: string[] | undefined;
+  extensions?: string[] | undefined;
+  formatterName?: string;
+  cache?: boolean;
+  cacheLocation?: string;
+  cwd?: string;
+};
+
+/** Default config of `Core` */
+export const DEFAULT_BASE_CONFIG = {
+  cache: true,
+  cacheLocation: join(getCacheDir(), '.eslintcache'),
+  formatterName: 'codeframe',
+};
+
+/**
+ * The core of eslint-interactive.
+ * It uses ESLint's Node.js API to output a summary of problems, fix problems, apply suggestions, etc.
+ */
+export class Core {
+  readonly config: Config;
+  /** The base options of ESLint */
+  readonly baseOptions: ESLint.Options;
+
+  constructor(config: Config) {
+    this.config = config;
+    this.baseOptions = {
+      cache: this.config.cache ?? DEFAULT_BASE_CONFIG.cache,
+      cacheLocation: this.config.cacheLocation ?? DEFAULT_BASE_CONFIG.cacheLocation,
+      rulePaths: this.config.rulePaths,
+      extensions: this.config.extensions,
+      cwd: this.config.cwd,
+    };
+  }
+
+  /**
+   * Lint project.
+   * @returns The results of linting
+   */
+  async lint(): Promise<ESLint.LintResult[]> {
+    const eslint = new ESLint(this.baseOptions);
+    const results = await eslint.lintFiles(this.config.patterns);
+    return results;
+  }
+
+  /**
+   * Returns summary of lint results.
+   * @param results The lint results of the project to print summary
+   */
+  formatResultSummary(results: ESLint.LintResult[]): string {
+    // get used plugins from `results`
+    const plugins = scanUsedPluginsFromResults(results);
+
+    // get `rulesMeta` from `results`
+    const eslint = new ESLint({
+      ...this.baseOptions,
+      overrideConfig: { plugins },
+    });
+    // NOTE: `getRulesMetaForResults` is a feature added in ESLint 7.29.0.
+    // Therefore, the function may not exist in versions lower than 7.29.0.
+    const rulesMeta: ESLint.LintResultData['rulesMeta'] = eslint.getRulesMetaForResults?.(results) ?? {};
+
+    return format(results, { rulesMeta: rulesMeta, cwd: this.config.cwd ?? process.cwd() });
+  }
+
+  /**
+   * Returns details of lint results.
+   * @param results The lint results of the project to print summary
+   * @param ruleIds The rule ids to print details
+   */
+  async formatResultDetails(results: ESLint.LintResult[], ruleIds: (string | null)[]): Promise<string> {
+    const eslint = new ESLint(this.baseOptions);
+    const formatterName = this.config.formatterName ?? DEFAULT_BASE_CONFIG.formatterName;
+
+    // When eslint-interactive is installed globally, eslint-formatter-codeframe will also be installed globally.
+    // On the other hand, `eslint.loadFormatter` cannot load the globally installed formatter by name. So here it loads them by path.
+    const resolvedFormatterNameOrPath =
+      isInstalledGlobally && formatterName === 'codeframe'
+        ? fileURLToPath(
+            // @ts-expect-error
+            await import.meta.resolve(
+              'eslint-formatter-codeframe',
+              // @ts-expect-error
+              await import.meta.resolve('eslint-interactive'),
+            ),
+          )
+        : formatterName;
+
+    const formatter = await eslint.loadFormatter(resolvedFormatterNameOrPath);
+    return formatter.format(filterResultsByRuleId(results, ruleIds));
+  }
+
+  /**
+   * Run `eslint --fix`.
+   * @param ruleIds The rule ids to fix
+   */
+  async applyAutoFixes(results: ESLint.LintResult[], ruleIds: string[]): Promise<Undo> {
+    return await this.fix(results, ruleIds, { name: 'applyAutoFixes', args: {} });
+  }
+
+  /**
+   * Add disable comments per line.
+   * @param results The lint results of the project to add disable comments
+   * @param ruleIds The rule ids to add disable comments
+   * @param description The description of the disable comments
+   */
+  async disablePerLine(results: ESLint.LintResult[], ruleIds: string[], description?: string): Promise<Undo> {
+    return await this.fix(results, ruleIds, { name: 'disablePerLine', args: { description } });
+  }
+
+  /**
+   * Add disable comments per file.
+   * @param results The lint results of the project to add disable comments
+   * @param ruleIds The rule ids to add disable comments
+   * @param description The description of the disable comments
+   */
+  async disablePerFile(results: ESLint.LintResult[], ruleIds: string[], description?: string): Promise<Undo> {
+    return await this.fix(results, ruleIds, { name: 'disablePerFile', args: { description } });
+  }
+
+  /**
+   * Apply suggestions.
+   * @param results The lint results of the project to apply suggestions
+   * @param ruleIds The rule ids to apply suggestions
+   * @param filter The script to filter suggestions
+   * */
+  async applySuggestions(results: ESLint.LintResult[], ruleIds: string[], filter: SuggestionFilter): Promise<Undo> {
+    return await this.fix(results, ruleIds, { name: 'applySuggestions', args: { filter } });
+  }
+
+  /**
+   * Make forcibly fixable and run `eslint --fix`.
+   * @param results The lint results of the project to apply suggestions
+   * @param ruleIds The rule ids to apply suggestions
+   * @param fixableMaker The function to make `Linter.LintMessage` forcibly fixable.
+   * */
+  async makeFixableAndFix(results: ESLint.LintResult[], ruleIds: string[], fixableMaker: FixableMaker): Promise<Undo> {
+    return await this.fix(results, ruleIds, { name: 'makeFixableAndFix', args: { fixableMaker } });
+  }
+
+  /**
+   * Fix source codes.
+   * @param fix The fix information to do.
+   */
+  private async fix(resultsOfLint: ESLint.LintResult[], ruleIds: string[], fix: Fix): Promise<Undo> {
+    // NOTE: Extract only necessary results and files for performance
+    const filteredResultsOfLint = filterResultsByRuleId(resultsOfLint, ruleIds);
+    const targetFilePaths = filteredResultsOfLint.map((result) => result.filePath);
+    const usedRuleIds = await getUsedRuleIds(targetFilePaths, this.baseOptions);
+
+    // TODO: refactor
+    let results = filteredResultsOfLint;
+    for (let i = 0; i < MAX_AUTOFIX_PASSES; i++) {
+      const eslint = new ESLint({
+        ...this.baseOptions,
+        // This is super hack to load ESM plugin/rule.
+        // ref: https://github.com/eslint/eslint/issues/15453#issuecomment-1001200953
+        plugins: {
+          'eslint-interactive': eslintInteractivePlugin,
+        },
+        overrideConfig: {
+          plugins: ['eslint-interactive'],
+          rules: {
+            'eslint-interactive/fix': [2, { results, ruleIds, fix } as FixRuleOption],
+            // Turn off all rules except `eslint-interactive/fix` when fixing for performance.
+            ...Object.fromEntries(usedRuleIds.map((ruleId) => [ruleId, 'off'])),
+          },
+        },
+        // NOTE: Only fix the `fix` rule problems.
+        fix: (message) => message.ruleId === 'eslint-interactive/fix',
+        // Don't interpret lintFiles arguments as glob patterns for performance.
+        globInputPaths: false,
+      });
+      const resultsToFix = await eslint.lintFiles(targetFilePaths);
+      await ESLint.outputFixes(resultsToFix);
+      if (!hasOverlappedProblems(resultsToFix)) break;
+      results = await this.lint();
+    }
+
+    return async () => {
+      const resultsToUndo = generateResultsToUndo(filteredResultsOfLint);
+      await ESLint.outputFixes(resultsToUndo);
+    };
+  }
+}

package/src/formatter/colors.ts

@@ -0,0 +1,5 @@
+/* istanbul ignore file */
+
+export const FAILED_COLOR = 'redBright' as const;
+export const ERROR_COLOR = 'red' as const;
+export const WARNING_COLOR = 'yellow' as const;

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

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { ESLint } from 'eslint';
+import { ERROR_COLOR, FAILED_COLOR, WARNING_COLOR } from './colors.js';
+
+function pluralize(word: string, count: number): string {
+  return count > 1 ? `${word}s` : word;
+}
+
+export function formatByFiles(results: ESLint.LintResult[]): string {
+  let errorCount = 0;
+  let failureCount = 0;
+  let passCount = 0;
+  let warningCount = 0;
+
+  results.forEach(function (result) {
+    const messages = result.messages;
+
+    if (messages.length === 0) {
+      passCount++;
+    } else {
+      failureCount++;
+      warningCount += result.warningCount;
+      errorCount += result.errorCount;
+    }
+  });
+
+  const fileCount = passCount + failureCount;
+  const problemCount = errorCount + warningCount;
+
+  let summary = '';
+  summary += `- ${fileCount} ${pluralize('file', fileCount)}`;
+  summary += ' (';
+  summary += `${passCount} ${pluralize('file', passCount)} passed`;
+  summary += ', ';
+  summary += chalk[FAILED_COLOR](`${failureCount} ${pluralize('file', failureCount)} failed`);
+  summary += ') checked.\n';
+
+  if (problemCount > 0) {
+    summary += `- ${problemCount} ${pluralize('problem', problemCount)}`;
+    summary += ' (';
+    summary += chalk[ERROR_COLOR](`${errorCount} ${pluralize('error', errorCount)}`);
+    summary += ', ';
+    summary += chalk[WARNING_COLOR](`${warningCount} ${pluralize('warning', warningCount)}`);
+    summary += ') found.';
+  }
+
+  return chalk.bold(summary);
+}

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

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+import Table = require('cli-table');
+import { ESLint } from 'eslint';
+// import terminalLink from 'terminal-link';
+import { ERROR_COLOR } from './colors.js';
+import { takeRuleStatistics } from './take-rule-statistics.js';
+
+function numCell(num: number): string {
+  return num > 0 ? chalk[ERROR_COLOR].bold(num) : num.toString();
+}
+
+export function formatByRules(results: ESLint.LintResult[], _data?: ESLint.LintResultData): string {
+  const ruleStatistics = takeRuleStatistics(results);
+  const table = new Table({
+    head: ['Rule', 'Error', 'Warning', 'is fixable', 'has suggestions'],
+  });
+
+  ruleStatistics.forEach((ruleStatistic) => {
+    const { ruleId, errorCount, warningCount, isFixableCount, hasSuggestionsCount } = ruleStatistic;
+
+    // NOTE: Disable documentation links temporarily due to problems with cli-table.
+    // ref: https://github.com/mizdra/eslint-interactive/issues/81
+    // const ruleMetaData = data?.rulesMeta[ruleId];
+    // const ruleCell = ruleMetaData?.docs?.url ? terminalLink(ruleId, ruleMetaData?.docs.url) : ruleId;
+    const ruleCell = ruleId;
+    table.push([
+      ruleCell,
+      numCell(errorCount),
+      numCell(warningCount),
+      numCell(isFixableCount),
+      numCell(hasSuggestionsCount),
+    ]);
+  });
+
+  return table.toString();
+}

package/src/formatter/index.ts

@@ -0,0 +1,9 @@
+import { ESLint } from 'eslint';
+import { formatByFiles } from './format-by-files.js';
+import { formatByRules } from './format-by-rules.js';
+
+export { takeRuleStatistics, type RuleStatistic } from './take-rule-statistics.js';
+
+export function format(results: ESLint.LintResult[], data?: ESLint.LintResultData): string {
+  return formatByFiles(results) + '\n' + formatByRules(results, data);
+}

package/src/formatter/take-rule-statistics.ts

@@ -0,0 +1,66 @@
+import { ESLint, Linter } from 'eslint';
+import { groupBy } from '../util/array.js';
+
+/**
+ * The type representing the lint results of a rule unit.
+ */
+export type RuleStatistic = {
+  ruleId: string;
+  errorCount: number;
+  warningCount: number;
+  isFixableCount: number;
+  isFixableErrorCount: number;
+  isFixableWarningCount: number;
+  hasSuggestionsCount: number;
+  hasSuggestionsErrorCount: number;
+  hasSuggestionsWarningCount: number;
+};
+
+/** 指定されたルールのエラー/警告の件数などの統計を取る */
+function takeRuleStatistic(ruleId: string, messages: Linter.LintMessage[]): RuleStatistic {
+  let errorCount = 0;
+  let warningCount = 0;
+  let isFixableErrorCount = 0;
+  let isFixableWarningCount = 0;
+  let hasSuggestionsErrorCount = 0;
+  let hasSuggestionsWarningCount = 0;
+
+  for (const message of messages) {
+    if (message.severity === 2) {
+      errorCount++;
+      if (message.fix) isFixableErrorCount++;
+      if (message.suggestions && message.suggestions.length > 0) hasSuggestionsErrorCount++;
+    } else if (message.severity === 1) {
+      warningCount++;
+      if (message.fix) isFixableWarningCount++;
+      if (message.suggestions && message.suggestions.length > 0) hasSuggestionsWarningCount++;
+    }
+  }
+
+  return {
+    ruleId,
+    errorCount,
+    warningCount,
+    isFixableCount: isFixableErrorCount + isFixableWarningCount,
+    isFixableErrorCount: isFixableErrorCount,
+    isFixableWarningCount: isFixableWarningCount,
+    hasSuggestionsCount: hasSuggestionsErrorCount + hasSuggestionsWarningCount,
+    hasSuggestionsErrorCount,
+    hasSuggestionsWarningCount,
+  };
+}
+
+/** ルールごとのエラー/警告の件数などの統計を取る */
+export function takeRuleStatistics(results: ESLint.LintResult[]): RuleStatistic[] {
+  const messages = results.flatMap((result) => result.messages).filter((message) => message.ruleId !== null);
+
+  const ruleIdToMessages = groupBy(messages, (message) => message.ruleId);
+
+  const ruleStatistics: RuleStatistic[] = [];
+  for (const [ruleId, messages] of ruleIdToMessages) {
+    // NOTE: Exclude problems with a null `ruleId`.
+    // ref: ref: https://github.com/eslint/eslint/blob/f1b7499a5162d3be918328ce496eb80692353a5a/docs/developer-guide/nodejs-api.md?plain=1#L372
+    if (ruleId !== null) ruleStatistics.push(takeRuleStatistic(ruleId, messages));
+  }
+  return ruleStatistics;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { run, type Options } from './cli/run.js';
+export { Core, type Config } from './core.js';
+export { takeRuleStatistics, type RuleStatistic } from './formatter/index.js';
+export { type FixableMaker, type SuggestionFilter, type FixContext } from './plugin/index.js';

package/src/plugin/fix/apply-auto-fixes.ts

@@ -0,0 +1,13 @@
+import { Rule } from 'eslint';
+import { notEmpty } from '../../util/type-check.js';
+import { FixContext } from '../index.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type FixToApplyAutoFixesArgs = {};
+
+/**
+ * Create fix to apply auto-fixes.
+ */
+export function createFixToApplyAutoFixes(context: FixContext, _args: FixToApplyAutoFixesArgs): Rule.Fix[] {
+  return context.messages.map((message) => message.fix).filter(notEmpty);
+}

package/src/plugin/fix/apply-suggestions.ts

@@ -0,0 +1,44 @@
+import { Linter, Rule } from 'eslint';
+import { FixContext } from '../index.js';
+
+export type SuggestionFilter = (
+  suggestions: Linter.LintSuggestion[],
+  message: Linter.LintMessage,
+  context: FixContext,
+) => Linter.LintSuggestion | null | undefined;
+
+export type FixToApplySuggestionsArgs = {
+  filter: SuggestionFilter;
+};
+
+function getApplicableSuggestion(
+  message: Linter.LintMessage,
+  filter: SuggestionFilter,
+  context: FixContext,
+): Linter.LintSuggestion | null {
+  if (!message.suggestions || message.suggestions.length === 0) return null;
+  const suggestion = filter(message.suggestions, message, context);
+  return suggestion ?? null;
+}
+
+function generateFixPerMessage(
+  context: FixContext,
+  filter: SuggestionFilter,
+  message: Linter.LintMessage,
+): Rule.Fix | null {
+  const suggestion = getApplicableSuggestion(message, filter, context);
+  if (!suggestion) return null;
+  return suggestion.fix;
+}
+
+/**
+ * Create fix to apply suggestions.
+ */
+export function createFixToApplySuggestions(context: FixContext, args: FixToApplySuggestionsArgs): Rule.Fix[] {
+  const fixes = [];
+  for (const message of context.messages) {
+    const fix = generateFixPerMessage(context, args.filter, message);
+    if (fix) fixes.push(fix);
+  }
+  return fixes;
+}

package/src/plugin/fix/disable-per-file.ts

@@ -0,0 +1,53 @@
+import { Rule } from 'eslint';
+import type { Comment } from 'estree';
+import { unique } from '../../util/array.js';
+import {
+  DisableComment,
+  findShebang,
+  mergeRuleIdsAndDescription,
+  parseDisableComment,
+  toCommentText,
+} from '../../util/eslint.js';
+import { notEmpty } from '../../util/type-check.js';
+import { FixContext } from '../index.js';
+
+export type FixToDisablePerFileArgs = {
+  description?: string;
+};
+
+function findDisableCommentPerFile(commentsInFile: Comment[]): DisableComment | undefined {
+  return commentsInFile.map(parseDisableComment).find((comment) => comment?.scope === 'file');
+}
+
+function generateFix(context: FixContext, description?: string): Rule.Fix | null {
+  const ruleIdsToDisable = unique(context.messages.map((message) => message.ruleId).filter(notEmpty));
+  if (ruleIdsToDisable.length === 0) return null;
+
+  const commentsInFile = context.sourceCode.getAllComments();
+  const disableCommentPerFile = findDisableCommentPerFile(commentsInFile);
+  if (disableCommentPerFile) {
+    const text = toCommentText({
+      type: 'Block',
+      scope: 'file',
+      ...mergeRuleIdsAndDescription(disableCommentPerFile, {
+        ruleIds: ruleIdsToDisable,
+        description,
+      }),
+    });
+    return context.fixer.replaceTextRange(disableCommentPerFile.range, text);
+  } else {
+    const text = toCommentText({ type: 'Block', scope: 'file', ruleIds: ruleIdsToDisable, description }) + '\n';
+
+    const shebang = findShebang(context.sourceCode.text);
+    // if shebang exists, insert comment after shebang
+    return context.fixer.insertTextAfterRange(shebang?.range ?? [0, 0], text);
+  }
+}
+
+/**
+ * Create fix to add disable comment per file.
+ */
+export function createFixToDisablePerFile(context: FixContext, args: FixToDisablePerFileArgs): Rule.Fix[] {
+  const fix = generateFix(context, args.description);
+  return fix ? [fix] : [];
+}

package/src/plugin/fix/disable-per-line.ts

@@ -0,0 +1,65 @@
+import { Linter, Rule } from 'eslint';
+import type { Comment } from 'estree';
+import { groupBy, unique } from '../../util/array.js';
+import { DisableComment, mergeRuleIdsAndDescription, parseDisableComment, toCommentText } from '../../util/eslint.js';
+import { notEmpty } from '../../util/type-check.js';
+import { FixContext } from '../index.js';
+
+export type FixToDisablePerLineArgs = {
+  description?: string;
+};
+
+function findDisableCommentPerLine(commentsInFile: Comment[], line: number): DisableComment | undefined {
+  const commentsInPreviousLine = commentsInFile.filter((comment) => comment.loc?.start.line === line - 1);
+  return commentsInPreviousLine.map(parseDisableComment).find((comment) => comment?.scope === 'next-line');
+}
+
+function generateFixPerLine(
+  context: FixContext,
+  description: string | undefined,
+  line: number,
+  messagesInLine: Linter.LintMessage[],
+): Rule.Fix | null {
+  const ruleIdsToDisable = unique(messagesInLine.map((message) => message.ruleId).filter(notEmpty));
+  if (ruleIdsToDisable.length === 0) return null;
+
+  const commentsInFile = context.sourceCode.getAllComments();
+  const disableCommentPerLine = findDisableCommentPerLine(commentsInFile, line);
+  if (disableCommentPerLine) {
+    const text = toCommentText({
+      type: 'Block',
+      scope: 'next-line',
+      ...mergeRuleIdsAndDescription(disableCommentPerLine, {
+        ruleIds: ruleIdsToDisable,
+        description,
+      }),
+    });
+    return context.fixer.replaceTextRange(disableCommentPerLine.range, text);
+  } else {
+    const headNodeIndex = context.sourceCode.getIndexFromLoc({ line: line, column: 0 });
+    const headNode = context.sourceCode.getNodeByRangeIndex(headNodeIndex);
+    if (headNode === null) return null; // For some reason, it seems to be null sometimes.
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if ((headNode.type as any) === 'JSXText') {
+      const commentText = toCommentText({ type: 'Block', scope: 'next-line', ruleIds: ruleIdsToDisable, description });
+      return context.fixer.insertTextBeforeRange([headNodeIndex, headNodeIndex], '{' + commentText + '}\n');
+    } else {
+      const commentText = toCommentText({ type: 'Line', scope: 'next-line', ruleIds: ruleIdsToDisable, description });
+      return context.fixer.insertTextBeforeRange([headNodeIndex, headNodeIndex], commentText + '\n');
+    }
+  }
+}
+
+/**
+ * Create fix to add disable comment per line.
+ */
+export function createFixToDisablePerLine(context: FixContext, args: FixToDisablePerLineArgs): Rule.Fix[] {
+  const lineToMessages = groupBy(context.messages, (message) => message.line);
+  const fixes = [];
+  for (const [line, messagesInLine] of lineToMessages) {
+    const fix = generateFixPerLine(context, args.description, line, messagesInLine);
+    if (fix) fixes.push(fix);
+  }
+  return fixes;
+}

package/src/plugin/fix/index.ts

@@ -0,0 +1,13 @@
+export {
+  type SuggestionFilter,
+  type FixToApplySuggestionsArgs,
+  createFixToApplySuggestions,
+} from './apply-suggestions.js';
+export { type FixToApplyAutoFixesArgs, createFixToApplyAutoFixes } from './apply-auto-fixes.js';
+export { type FixToDisablePerFileArgs, createFixToDisablePerFile } from './disable-per-file.js';
+export { type FixToDisablePerLineArgs, createFixToDisablePerLine } from './disable-per-line.js';
+export {
+  type FixableMaker,
+  type FixToMakeFixableAndFixArgs,
+  createFixToMakeFixableAndFix,
+} from './make-fixable-and-fix.js';

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

@@ -0,0 +1,77 @@
+import { Linter, Rule, SourceCode } from 'eslint';
+import { traverse } from 'estraverse';
+import type { Node } from 'estree';
+import { unreachable } from '../../util/type-check.js';
+import { FixContext } from '../index.js';
+
+export type FixableMaker = (
+  message: Linter.LintMessage,
+  node: Node | null,
+  context: FixContext,
+) => Rule.Fix | null | undefined;
+
+export type FixToMakeFixableAndFixArgs = {
+  fixableMaker: FixableMaker;
+};
+
+/**
+ * Check the node is the source of the message.
+ */
+function isMessageSourceNode(sourceCode: SourceCode, node: Node, message: Linter.LintMessage): boolean {
+  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();
+
+  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,
+  });
+  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;
+}
+
+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);
+    if (fix) fixes.push(fix);
+  }
+  return fixes;
+}
+
+/**
+ * Create fix to make fixable and fix.
+ */
+export function createFixToMakeFixableAndFix(context: FixContext, args: FixToMakeFixableAndFixArgs): Rule.Fix[] {
+  return generateFixes(context, args);
+}