eslint-interactive 11.0.2 → 11.1.0

package/src/config.ts

@@ -1,8 +1,9 @@
-import type { LegacyESLint, FlatESLint } from 'eslint/use-at-your-own-risk';
+import { ESLint } from 'eslint';
 import { cliOptionsDefaults, ParsedCLIOptions } from './cli/parse-argv.js';
+import { FlatESLint } from './eslint/use-at-your-own-risk.js';
 import { DeepPartial } from './util/type-check.js';
 type LegacyESLintOptions = { type: 'eslintrc' } & Pick<
-  LegacyESLint.Options,
+  ESLint.Options,
   | 'useEslintrc'
   | 'overrideConfigFile'
   | 'extensions'
@@ -13,6 +14,7 @@ type LegacyESLintOptions = { type: 'eslintrc' } & Pick<
   | 'overrideConfig'
   | 'cwd'
   | 'resolvePluginsRelativeTo'
+  | 'plugins'
 >;
 type FlatESLintOptions = { type: 'flat' } & Pick<
   FlatESLint.Options,
@@ -110,6 +112,7 @@ export function normalizeConfig(config: Config): NormalizedConfig {
       cwd,
       resolvePluginsRelativeTo:
         config.eslintOptions.resolvePluginsRelativeTo ?? configDefaults.eslintOptions.resolvePluginsRelativeTo,
+      plugins: config.eslintOptions.plugins,
     };
   } else {
     eslintOptions = {

package/src/core.ts

@@ -1,10 +1,8 @@
 import { writeFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { ESLint, Linter, Rule } from 'eslint';
-import eslintPkg, { LegacyESLint as LegacyESLintNS } from 'eslint/use-at-your-own-risk';
-import isInstalledGlobally from 'is-installed-globally';
+import { ESLint, Rule } from 'eslint';
 import { DescriptionPosition } from './cli/prompt.js';
 import { Config, NormalizedConfig, normalizeConfig } from './config.js';
+import { LegacyESLint, FlatESLint } from './eslint/use-at-your-own-risk.js';
 import {
   createFixToApplyAutoFixes,
   createFixToApplySuggestions,
@@ -18,16 +16,15 @@ import {
   verifyAndFix,
 } from './fix/index.js';
 import { format } from './formatter/index.js';
+import { plugin } from './plugin.js';
 import { filterResultsByRuleId } from './util/eslint.js';
 
-const { LegacyESLint, FlatESLint } = eslintPkg;
-
 /**
  * Generate results to undo.
  * @param resultsOfLint The results of lint.
  * @returns The results to undo.
  */
-function generateResultsToUndo(resultsOfLint: LegacyESLintNS.LintResult[]): LegacyESLintNS.LintResult[] {
+function generateResultsToUndo(resultsOfLint: ESLint.LintResult[]): ESLint.LintResult[] {
   return resultsOfLint.map((resultOfLint) => {
     // NOTE: THIS IS HACK.
     return { ...resultOfLint, output: resultOfLint.source };
@@ -42,17 +39,47 @@ export type Undo = () => Promise<void>;
  */
 export class Core {
   readonly config: NormalizedConfig;
-  readonly eslint: LegacyESLintNS;
+  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);
+      this.eslint = new LegacyESLint({
+        ...rest,
+        plugins: {
+          ...rest.plugins,
+          'eslint-interactive': plugin,
+        },
+        overrideConfig: {
+          ...rest.overrideConfig,
+          plugins: [...(rest.overrideConfig?.plugins ?? []), 'eslint-interactive'],
+          rules: {
+            ...rest.overrideConfig?.rules,
+            'eslint-interactive/source-code-snatcher': 'error',
+          },
+        },
+      });
     } else {
       const { type, ...rest } = eslintOptions;
-      this.eslint = new FlatESLint(rest);
+      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',
+            },
+          },
+        ],
+      });
     }
   }
 
@@ -80,17 +107,9 @@ export class Core {
    * @param results The lint results of the project to print summary
    * @param ruleIds The rule ids to print details
    */
-  async formatResultDetails(results: LegacyESLintNS.LintResult[], ruleIds: (string | null)[]): Promise<string> {
+  async formatResultDetails(results: ESLint.LintResult[], ruleIds: (string | null)[]): Promise<string> {
     const formatterName = this.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(import.meta.resolve('eslint-formatter-codeframe', import.meta.resolve('eslint-interactive')))
-        : formatterName;
-
-    const formatter = await this.eslint.loadFormatter(resolvedFormatterNameOrPath);
+    const formatter = await this.eslint.loadFormatter(formatterName);
     return formatter.format(filterResultsByRuleId(results, ruleIds));
   }
 
@@ -98,7 +117,7 @@ export class Core {
    * Run `eslint --fix`.
    * @param ruleIds The rule ids to fix
    */
-  async applyAutoFixes(results: LegacyESLintNS.LintResult[], ruleIds: string[]): Promise<Undo> {
+  async applyAutoFixes(results: ESLint.LintResult[], ruleIds: string[]): Promise<Undo> {
     return this.fix(results, ruleIds, (context) => createFixToApplyAutoFixes(context, {}));
   }
 
@@ -110,7 +129,7 @@ export class Core {
    * @param descriptionPosition The position of the description
    */
   async disablePerLine(
-    results: LegacyESLintNS.LintResult[],
+    results: ESLint.LintResult[],
     ruleIds: string[],
     description?: string,
     descriptionPosition?: DescriptionPosition,
@@ -128,7 +147,7 @@ export class Core {
    * @param descriptionPosition The position of the description
    */
   async disablePerFile(
-    results: LegacyESLintNS.LintResult[],
+    results: ESLint.LintResult[],
     ruleIds: string[],
     description?: string,
     descriptionPosition?: DescriptionPosition,
@@ -145,7 +164,7 @@ export class Core {
    * @param description The comment explaining the reason for converting
    */
   async convertErrorToWarningPerFile(
-    results: LegacyESLintNS.LintResult[],
+    results: ESLint.LintResult[],
     ruleIds: string[],
     description?: string,
   ): Promise<Undo> {
@@ -158,11 +177,7 @@ export class Core {
    * @param ruleIds The rule ids to apply suggestions
    * @param filter The script to filter suggestions
    */
-  async applySuggestions(
-    results: LegacyESLintNS.LintResult[],
-    ruleIds: string[],
-    filter: SuggestionFilter,
-  ): Promise<Undo> {
+  async applySuggestions(results: ESLint.LintResult[], ruleIds: string[], filter: SuggestionFilter): Promise<Undo> {
     return this.fix(results, ruleIds, (context) => createFixToApplySuggestions(context, { filter }));
   }
 
@@ -172,11 +187,7 @@ export class Core {
    * @param ruleIds The rule ids to apply suggestions
    * @param fixableMaker The function to make `Linter.LintMessage` forcibly fixable.
    */
-  async makeFixableAndFix(
-    results: LegacyESLintNS.LintResult[],
-    ruleIds: string[],
-    fixableMaker: FixableMaker,
-  ): Promise<Undo> {
+  async makeFixableAndFix(results: ESLint.LintResult[], ruleIds: string[], fixableMaker: FixableMaker): Promise<Undo> {
     return this.fix(results, ruleIds, (context) => createFixToMakeFixableAndFix(context, { fixableMaker }));
   }
 
@@ -185,26 +196,19 @@ export class Core {
    * @param fix The fix information to do.
    */
   private async fix(
-    resultsOfLint: LegacyESLintNS.LintResult[],
+    resultsOfLint: ESLint.LintResult[],
     ruleIds: string[],
     fixCreator: (context: FixContext) => Rule.Fix[],
   ): Promise<Undo> {
     // NOTE: Extract only necessary results and files for performance
     const filteredResultsOfLint = filterResultsByRuleId(resultsOfLint, ruleIds);
-    const linter = new Linter({ configType: this.config.eslintOptions.type });
 
     // eslint-disable-next-line prefer-const
     for (let { filePath, source } of filteredResultsOfLint) {
       if (!source) throw new Error('Source code is required to apply fixes.');
-      const config: Linter.Config | Linter.FlatConfig[] =
-        this.config.eslintOptions.type === 'eslintrc'
-          ? // eslint-disable-next-line no-await-in-loop
-            await this.eslint.calculateConfigForFile(filePath)
-          : // NOTE: For some reason, if files is not specified, it will not match .jsx
-            // eslint-disable-next-line no-await-in-loop
-            [{ ...(await this.eslint.calculateConfigForFile(filePath)), files: ['**/*.*', '**/*'] }];
-
-      const fixedResult = verifyAndFix(linter, source, config, filePath, ruleIds, fixCreator);
+
+      // eslint-disable-next-line no-await-in-loop
+      const fixedResult = await verifyAndFix(this.eslint, source, filePath, ruleIds, fixCreator);
 
       // Write the fixed source code to the file
       if (fixedResult.fixed) {

package/src/eslint/linter.ts

@@ -7,8 +7,9 @@
  * @author aladdin-add
  */
 
-import { Linter, Rule } from 'eslint';
+import { ESLint, Rule } from 'eslint';
 import { FixContext } from '../fix/index.js';
+import { getLastSourceCode } from '../plugin.js';
 import { ruleFixer } from './rule-fixer.js';
 import { SourceCodeFixer } from './source-code-fixer.js';
 
@@ -24,14 +25,13 @@ type FixedResult = {
  * @param linter
  */
 // eslint-disable-next-line max-params
-export function verifyAndFix(
-  linter: Linter,
+export async function verifyAndFix(
+  eslint: ESLint,
   text: string,
-  config: Linter.Config | Linter.FlatConfig[],
   filePath: string,
   ruleIds: string[],
   fixCreator: (context: FixContext) => Rule.Fix[],
-): FixedResult {
+): Promise<FixedResult> {
   let fixedResult: FixedResult;
   let fixed = false;
   let passNumber = 0;
@@ -49,10 +49,13 @@ export function verifyAndFix(
   do {
     passNumber++;
 
-    const messages = linter
-      .verify(currentText, config, filePath)
+    // eslint-disable-next-line no-await-in-loop
+    const results = await eslint.lintText(currentText, { filePath });
+    const messages = results
+      .flatMap((result) => result.messages)
       .filter((message) => message.ruleId && ruleIds.includes(message.ruleId));
-    const sourceCode = linter.getSourceCode();
+    const sourceCode = getLastSourceCode();
+    if (!sourceCode) throw new Error('Failed to get the last source code.');
 
     // Create `Rule.Fix[]`
     const fixContext: FixContext = {

package/src/eslint/use-at-your-own-risk.d.ts

@@ -0,0 +1,62 @@
+import { ESLint, Linter, Rule } from 'eslint';
+
+/** @deprecated */
+export const LegacyESLint: typeof ESLint;
+
+/** @deprecated */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace FlatESLint {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface Options {
+    // File enumeration
+    cwd?: string | undefined;
+    errorOnUnmatchedPattern?: boolean | undefined;
+    globInputPaths?: boolean | undefined;
+    ignore?: boolean | undefined;
+
+    // Linting
+    allowInlineConfig?: boolean | undefined;
+    baseConfig?: Linter.FlatConfig | Linter.FlatConfig[] | undefined;
+    overrideConfig?: Linter.FlatConfig | Linter.FlatConfig[] | undefined;
+    overrideConfigFile?: boolean | string | undefined;
+    reportUnusedDisableDirectives?: Linter.StringSeverity | undefined;
+
+    // Autofix
+    fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;
+    fixTypes?: Rule.RuleMetaData['type'][] | undefined;
+
+    // Cache-related
+    cache?: boolean | undefined;
+    cacheLocation?: string | undefined;
+    cacheStrategy?: 'content' | 'metadata' | undefined;
+  }
+}
+/** @deprecated */
+export declare class FlatESLint {
+  constructor(options?: FlatESLint.Options);
+
+  static get version(): string;
+
+  static outputFixes(results: ESLint.LintResult[]): Promise<void>;
+
+  static getErrorResults(results: ESLint.LintResult[]): ESLint.LintResult[];
+
+  getRulesMetaForResults(results: ESLint.LintResult[]): Record<string, Rule.RuleMetaData>;
+
+  lintFiles(patterns: string | string[]): Promise<ESLint.LintResult[]>;
+
+  lintText(
+    code: string,
+    options?: { filePath?: string | undefined; warnIgnored?: boolean | undefined },
+  ): Promise<ESLint.LintResult[]>;
+
+  loadFormatter(name?: string): Promise<ESLint.Formatter>;
+
+  calculateConfigForFile(filePath: string): Promise<Linter.FlatConfig | undefined>;
+
+  findConfigFile(): Promise<string | undefined>;
+
+  isPathIgnored(filePath: string): Promise<boolean>;
+}
+/** @deprecated */
+export function shouldUseFlatConfig(): Promise<boolean>;

package/src/eslint/use-at-your-own-risk.js

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import eslintPkg from 'eslint/use-at-your-own-risk';
+
+export const LegacyESLint = eslintPkg.LegacyESLint;
+export const FlatESLint = eslintPkg.FlatESLint;
+export const shouldUseFlatConfig = eslintPkg.shouldUseFlatConfig;

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

@@ -39,10 +39,9 @@ function generateFix(
 
   // if shebang exists, insert comment after shebang
   const shebang = findShebang(context.sourceCode.text);
-  const lineToInsert = disableCommentPerFile
-    ? disableCommentPerFile.loc.start.line
-    : shebang
-    ? sourceCode.getLocFromIndex(shebang.range[0]).line + 1
+  const lineToInsert =
+    disableCommentPerFile ? disableCommentPerFile.loc.start.line
+    : shebang ? sourceCode.getLocFromIndex(shebang.range[0]).line + 1
     : 1;
 
   const fixes: Rule.Fix[] = [];
@@ -54,6 +53,7 @@ function generateFix(
         fixer,
         sourceCode,
         line: lineToInsert,
+        column: 0,
         description,
       }),
     );
@@ -65,8 +65,9 @@ function generateFix(
         fixer,
         disableComment: disableCommentPerFile,
         newRules: mergeRuleIds(disableCommentPerFile.ruleIds, ruleIdsToDisable),
-        newDescription: isPreviousLine
-          ? disableCommentPerFile.description
+        newDescription:
+          isPreviousLine ?
+            disableCommentPerFile.description
           : mergeDescription(disableCommentPerFile.description, description),
       }),
     );
@@ -76,6 +77,7 @@ function generateFix(
         fixer,
         sourceCode,
         line: lineToInsert,
+        column: 0,
         scope: 'file',
         ruleIds: ruleIdsToDisable,
         description: isPreviousLine ? undefined : description,

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

@@ -4,8 +4,10 @@ import { mergeFixes } from '../eslint/report-translator.js';
 import { groupBy, unique } from '../util/array.js';
 import {
   DisableComment,
+  getStartColumnOfTemplateExpression,
   insertDescriptionCommentStatementBeforeLine,
   insertDisableCommentStatementBeforeLine,
+  isLineInTemplateLiteral,
   mergeDescription,
   mergeRuleIds,
   parseDisableComment,
@@ -30,6 +32,7 @@ function generateFixesPerLine(
   description: string | undefined,
   descriptionPosition: DescriptionPosition | undefined,
   line: number,
+  column: number,
   messagesInLine: Linter.LintMessage[],
 ): Rule.Fix | null {
   const { fixer, sourceCode } = context;
@@ -48,6 +51,7 @@ function generateFixesPerLine(
         fixer,
         sourceCode,
         line: disableCommentPerLine ? disableCommentPerLine.loc.start.line : line,
+        column,
         description,
       }),
     );
@@ -58,8 +62,9 @@ function generateFixesPerLine(
         fixer,
         disableComment: disableCommentPerLine,
         newRules: mergeRuleIds(disableCommentPerLine.ruleIds, ruleIdsToDisable),
-        newDescription: isPreviousLine
-          ? disableCommentPerLine.description
+        newDescription:
+          isPreviousLine ?
+            disableCommentPerLine.description
           : mergeDescription(disableCommentPerLine.description, description),
       }),
     );
@@ -69,6 +74,7 @@ function generateFixesPerLine(
         fixer,
         sourceCode,
         line,
+        column,
         scope: 'next-line',
         ruleIds: ruleIdsToDisable,
         description: isPreviousLine ? undefined : description,
@@ -82,10 +88,18 @@ function generateFixesPerLine(
  * 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 groupedMessages = groupBy(context.messages, (message) => {
+    if (isLineInTemplateLiteral(context.sourceCode, message.line)) {
+      const column = getStartColumnOfTemplateExpression(context.sourceCode, message);
+      return `${message.line}:${column}`;
+    } else {
+      return `${message.line}:0`;
+    }
+  });
   const fixes: Rule.Fix[] = [];
-  for (const [line, messagesInLine] of lineToMessages) {
-    const fix = generateFixesPerLine(context, args.description, args.descriptionPosition, line, messagesInLine);
+  for (const [lineAndColumn, messagesInLine] of groupedMessages) {
+    const [line, column] = lineAndColumn.split(':').map(Number) as [number, number];
+    const fix = generateFixesPerLine(context, args.description, args.descriptionPosition, line, column, messagesInLine);
     if (fix) fixes.push(fix);
   }
   return fixes;

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

@@ -44,9 +44,8 @@ export function formatByRules(results: ESLint.LintResult[], data?: ESLint.LintRe
   ruleStatistics.forEach((ruleStatistic) => {
     const { ruleId } = ruleStatistic;
     const ruleMetaData = data?.rulesMeta[ruleId];
-    const ruleCell = ruleMetaData?.docs?.url
-      ? terminalLink(ruleId, ruleMetaData?.docs.url, { fallback: false })
-      : ruleId;
+    const ruleCell =
+      ruleMetaData?.docs?.url ? terminalLink(ruleId, ruleMetaData?.docs.url, { fallback: false }) : ruleId;
     result = result.replace(` ${ruleId} `, ` ${ruleCell} `);
   });
 

package/src/plugin.ts

@@ -0,0 +1,71 @@
+import { ESLint, Rule, SourceCode } from 'eslint';
+
+let lastSourceCode: SourceCode | null = null;
+
+export function getLastSourceCode() {
+  return lastSourceCode;
+}
+
+export const plugin: ESLint.Plugin = {
+  rules: {
+    /**
+     * This is a rule for getting a `SourceCode` instance.
+     * `ESLint` class does not provide a method for getting a `SourceCode` instance. As an alternative, we have prepared this custom rule.
+     */
+    'source-code-snatcher': {
+      create(context) {
+        lastSourceCode = context.sourceCode;
+        return {};
+      },
+    },
+    /** This is a rule for testing purposes. */
+    'prefer-addition-shorthand': {
+      meta: {
+        type: 'suggestion',
+        // @ts-ignore
+        hasSuggestions: true,
+      },
+      create(context: Rule.RuleContext) {
+        return {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          AssignmentExpression: (node) => {
+            if (node.left.type !== 'Identifier') return;
+            const leftIdentifier = node.left;
+            if (node.right.type !== 'BinaryExpression') return;
+            const rightBinaryExpression = node.right;
+            if (rightBinaryExpression.operator !== '+') return;
+            if (rightBinaryExpression.left.type !== 'Identifier') return;
+            const rightIdentifier = rightBinaryExpression.left;
+            if (leftIdentifier.name !== rightIdentifier.name) return;
+            if (rightBinaryExpression.right.type !== 'Literal' || rightBinaryExpression.right.value !== 1) return;
+
+            context.report({
+              node,
+              message: 'The addition method is redundant.',
+              suggest: [
+                {
+                  desc: 'Use `val += 1` instead.',
+                  fix(fixer) {
+                    return fixer.replaceText(node, `${leftIdentifier.name} += 1`);
+                  },
+                },
+                {
+                  desc: 'Use `val++` instead.',
+                  fix(fixer) {
+                    return fixer.replaceText(node, `${leftIdentifier.name}++`);
+                  },
+                },
+                {
+                  desc: 'Use `++val` instead.',
+                  fix(fixer) {
+                    return fixer.replaceText(node, `++${leftIdentifier.name}`);
+                  },
+                },
+              ],
+            });
+          },
+        };
+      },
+    },
+  },
+};

package/src/util/eslint.ts

@@ -109,6 +109,27 @@ function isLineInJSXText(sourceCode: SourceCode, line: number): boolean {
   return headNode?.type === 'JSXText';
 }
 
+export function isLineInTemplateLiteral(sourceCode: SourceCode, line: number): boolean {
+  const headNodeIndex = sourceCode.getIndexFromLoc({ line, column: 0 });
+  const headNode = sourceCode.getNodeByRangeIndex(headNodeIndex);
+  return headNode?.type === 'TemplateElement';
+}
+
+export function getStartColumnOfTemplateExpression(sourceCode: SourceCode, message: Linter.LintMessage): number {
+  for (let i = message.column; i >= 1; i--) {
+    const index = sourceCode.getIndexFromLoc({
+      line: message.line,
+      // Convert 1-indexed to 0-indexed
+      column: i - 1,
+    });
+    const node = sourceCode.getNodeByRangeIndex(index);
+    if (node?.type === 'TemplateElement') {
+      return i;
+    }
+  }
+  throw new Error(`unreachable: The line ${message.line} does not have a template element.`);
+}
+
 /**
  * Merge the ruleIds of the disable comments.
  * @param a The ruleIds of first disable comment
@@ -136,11 +157,12 @@ export function insertDescriptionCommentStatementBeforeLine(args: {
   fixer: Rule.RuleFixer;
   sourceCode: SourceCode;
   line: number;
+  column: number;
   description: string;
 }): Rule.Fix {
-  const { fixer, sourceCode, line, description } = args;
+  const { fixer, sourceCode, line, column, description } = args;
   const indent = getIndentFromLine(sourceCode, line);
-  const headNodeIndex = sourceCode.getIndexFromLoc({ line, column: 0 });
+  const headNodeIndex = sourceCode.getIndexFromLoc({ line, column });
 
   if (isLineInJSXText(sourceCode, line)) {
     const commentText = toCommentText({ type: 'Block', text: description });
@@ -175,13 +197,14 @@ export function insertDisableCommentStatementBeforeLine(args: {
   fixer: Rule.RuleFixer;
   sourceCode: SourceCode;
   line: number;
+  column: number;
   scope: 'file' | 'next-line';
   ruleIds: string[];
   description: string | undefined;
 }) {
-  const { fixer, sourceCode, line, scope, ruleIds, description } = args;
+  const { fixer, sourceCode, line, column, scope, ruleIds, description } = args;
   const indent = getIndentFromLine(sourceCode, line);
-  const headNodeIndex = sourceCode.getIndexFromLoc({ line, column: 0 });
+  const headNodeIndex = sourceCode.getIndexFromLoc({ line, column });
   const isInJSXText = isLineInJSXText(sourceCode, line);
   const type = isInJSXText || scope === 'file' ? 'Block' : 'Line';
   const disableCommentText = toDisableCommentText({