eslint-interactive 8.1.0

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "eslint-interactive",
+  "description": "The CLI tool to run `eslint --fix` for each rule",
+  "version": "8.1.0",
+  "repository": "https://github.com/mizdra/eslint-interactive.git",
+  "author": "mizdra <pp.mizdra@gmail.com>",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "exports": "./dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.src.json",
+    "dev": "tsc-watch -p tsconfig.src.json --onSuccess 'bin/eslint-interactive.js fixtures --rulesdir fixtures/rules --ext .js,.jsx,.mjs'",
+    "lint": "run-s -c lint:*",
+    "lint:tsc": "run-s -c lint:tsc:*",
+    "lint:tsc:src": "tsc -p tsconfig.src.json --noEmit",
+    "lint:tsc:test": "tsc -p tsconfig.test.json --noEmit",
+    "lint:eslint": "eslint --ignore-pattern '/fixtures/' --ignore-pattern '/e2e-test/' .",
+    "lint:prettier": "prettier --check .",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --colors",
+    "postbuild:test": "./run-e2e-test.sh",
+    "postbuild:benchmark": "node benchmark/run.js"
+  },
+  "prettier": "@mizdra/prettier-config-mizdra",
+  "renovate": "github>mizdra/renovate-config-mizdra",
+  "devDependencies": {
+    "@jest/types": "^27.5.1",
+    "@mizdra/eslint-config-mizdra": "^1.1.0",
+    "@mizdra/prettier-config-mizdra": "^0.4.0",
+    "@types/cli-table": "^0.3.0",
+    "@types/eslint": "^8.4.1",
+    "@types/estraverse": "^5.1.1",
+    "@types/estree": "^0.0.50",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^14.14.10",
+    "@types/terminal-link": "^1.2.0",
+    "@types/yargs": "^16.0.4",
+    "@typescript-eslint/eslint-plugin": "^5.11.0",
+    "@typescript-eslint/parser": "^5.11.0",
+    "enhanced-resolve": "^5.8.3",
+    "eslint": "^8.9.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.4",
+    "jest": "^27.5.1",
+    "jest-mock-process": "^1.4.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "2.5.1",
+    "strip-ansi": "^7.0.1",
+    "ts-jest": "^27.1.3",
+    "tsc-watch": "^4.2.9",
+    "typescript": "^4.6.0-dev.20220210"
+  },
+  "dependencies": {
+    "boxen": "^6.2.1",
+    "cachedir": "^2.3.0",
+    "chalk": "^5.0.0",
+    "cli-table": "^0.3.11",
+    "comlink": "^4.3.1",
+    "enquirer": "^2.3.6",
+    "eslint-formatter-codeframe": "^7.32.1",
+    "estraverse": "^5.3.0",
+    "is-installed-globally": "^0.4.0",
+    "node-pager": "^0.3.6",
+    "ora": "^6.0.1",
+    "terminal-link": "^3.0.0",
+    "yargs": "^16.2.0"
+  },
+  "peerDependencies": {
+    "eslint": "^7.0.0 || ^8.0.0"
+  },
+  "engines": {
+    "node": "^14.13.1 || >=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bin": {
+    "eslint-interactive": "bin/eslint-interactive.js"
+  },
+  "keywords": [
+    "eslint"
+  ],
+  "files": [
+    "bin",
+    "src",
+    "!src/test-util",
+    "!src/**/*.test.ts",
+    "!src/**/__snapshots__",
+    "dist",
+    "static"
+  ]
+}

package/src/action/apply-suggestions.ts

@@ -0,0 +1,40 @@
+import { access, mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import { fixingSpinner } from '../cli/ora.js';
+import { promptToInputReuseFilterScript } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+import { Undo } from '../core.js';
+import {
+  editFileWithEditor,
+  generateExampleFilterScriptFilePath,
+  generateFilterScriptFilePath,
+} from '../util/filter-script.js';
+
+export async function doApplySuggestionsAction(
+  core: Remote<SerializableCore>,
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+): Promise<Undo> {
+  const exampleScript = await readFile(generateExampleFilterScriptFilePath(), 'utf8');
+  const filterScriptFilePath = generateFilterScriptFilePath(selectedRuleIds);
+  const isFilterScriptExist = await access(filterScriptFilePath)
+    .then(() => true)
+    .catch(() => false);
+  if (isFilterScriptExist) {
+    const reuseFilterScript = await promptToInputReuseFilterScript();
+    if (!reuseFilterScript) {
+      await writeFile(filterScriptFilePath, exampleScript);
+    }
+  } else {
+    // ディレクトリがない可能性を考慮して作成しておく
+    await mkdir(dirname(filterScriptFilePath), { recursive: true });
+    await writeFile(filterScriptFilePath, exampleScript);
+  }
+  console.log('Opening editor...');
+
+  const filterScript = await editFileWithEditor(filterScriptFilePath);
+  const undo = await fixingSpinner(async () => core.applySuggestions(results, selectedRuleIds, filterScript));
+  return undo;
+}

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

@@ -0,0 +1,16 @@
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import { fixingSpinner } from '../cli/ora.js';
+import { promptToInputDescription } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+import { Undo } from '../core.js';
+
+export async function doDisablePerFileAction(
+  core: Remote<SerializableCore>,
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+): Promise<Undo> {
+  const description = await promptToInputDescription();
+  const undo = await fixingSpinner(async () => core.disablePerFile(results, selectedRuleIds, description));
+  return undo;
+}

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

@@ -0,0 +1,16 @@
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import { fixingSpinner } from '../cli/ora.js';
+import { promptToInputDescription } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+import { Undo } from '../core.js';
+
+export async function doDisablePerLineAction(
+  core: Remote<SerializableCore>,
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+): Promise<Undo> {
+  const description = await promptToInputDescription();
+  const undo = await fixingSpinner(async () => core.disablePerLine(results, selectedRuleIds, description));
+  return undo;
+}

package/src/action/fix.ts

@@ -0,0 +1,14 @@
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import { fixingSpinner } from '../cli/ora.js';
+import { SerializableCore } from '../core-worker.js';
+import { Undo } from '../core.js';
+
+export async function doFixAction(
+  core: Remote<SerializableCore>,
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+): Promise<Undo> {
+  const undo = await fixingSpinner(async () => core.applyAutoFixes(results, selectedRuleIds));
+  return undo;
+}

package/src/action/index.ts

@@ -0,0 +1,6 @@
+export { doApplySuggestionsAction } from './apply-suggestions.js';
+export { doDisablePerFileAction } from './disable-per-file.js';
+export { doDisablePerLineAction } from './disable-per-line.js';
+export { doFixAction } from './fix.js';
+export { doMakeFixableAndFixAction } from './make-fixable-and-fix.js';
+export { doPrintResultDetailsAction } from './print-result-details.js';

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

@@ -0,0 +1,40 @@
+import { access, mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import { fixingSpinner } from '../cli/ora.js';
+import { promptToInputReuseScript } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+import { Undo } from '../core.js';
+import {
+  editFileWithEditor,
+  generateExampleFixableMakerScriptFilePath,
+  generateFixableMakerScriptFilePath,
+} from '../util/filter-script.js';
+
+export async function doMakeFixableAndFixAction(
+  core: Remote<SerializableCore>,
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+): Promise<Undo> {
+  const exampleScript = await readFile(generateExampleFixableMakerScriptFilePath(), 'utf8');
+  const fixableMakerScriptFilePath = generateFixableMakerScriptFilePath(selectedRuleIds);
+  const isFixableMakerScriptExist = await access(fixableMakerScriptFilePath)
+    .then(() => true)
+    .catch(() => false);
+  if (isFixableMakerScriptExist) {
+    const reuseScript = await promptToInputReuseScript();
+    if (!reuseScript) {
+      await writeFile(fixableMakerScriptFilePath, exampleScript);
+    }
+  } else {
+    // ディレクトリがない可能性を考慮して作成しておく
+    await mkdir(dirname(fixableMakerScriptFilePath), { recursive: true });
+    await writeFile(fixableMakerScriptFilePath, exampleScript);
+  }
+  console.log('Opening editor...');
+
+  const fixableMakerScript = await editFileWithEditor(fixableMakerScriptFilePath);
+  const undo = await fixingSpinner(async () => core.makeFixableAndFix(results, selectedRuleIds, fixableMakerScript));
+  return undo;
+}

package/src/action/print-result-details.ts

@@ -0,0 +1,18 @@
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import pager from 'node-pager';
+import { promptToInputDisplayMode } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+
+export async function doPrintResultDetailsAction(
+  core: Remote<SerializableCore>,
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+) {
+  const displayMode = await promptToInputDisplayMode();
+  if (displayMode === 'withPager') {
+    await pager(await core.formatResultDetails(results, selectedRuleIds));
+  } else {
+    console.log(await core.formatResultDetails(results, selectedRuleIds));
+  }
+}

package/src/cli/log.ts

@@ -0,0 +1,11 @@
+import boxen from 'boxen';
+
+/**
+ * Log a warning message to stderr
+ * @param message The message to warn
+ */
+export function warn(message: string) {
+  console.error(
+    boxen(message, { title: 'WARNING', borderColor: 'yellow', padding: { top: 0, left: 1, right: 1, bottom: 0 } }),
+  );
+}

package/src/cli/ora.ts

@@ -0,0 +1,25 @@
+import { oraPromise } from 'ora';
+
+export async function lintingSpinner<T>(cb: () => Promise<T>): Promise<T> {
+  return oraPromise(cb, {
+    text: 'Linting...',
+    spinner: 'clock',
+    successText: 'Linting done.',
+  });
+}
+
+export async function fixingSpinner<T>(cb: () => Promise<T>): Promise<T> {
+  return oraPromise(cb, {
+    text: 'Fixing...',
+    spinner: 'clock',
+    successText: 'Fixing done.',
+  });
+}
+
+export async function undoingSpinner<T>(cb: () => Promise<T>): Promise<T> {
+  return oraPromise(cb, {
+    text: 'Undoing...',
+    spinner: 'timeTravel',
+    successText: 'Undoing done.',
+  });
+}

package/src/cli/package.ts

@@ -0,0 +1,9 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const PACKAGE_JSON = JSON.parse(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json'), 'utf8'),
+);
+
+export const VERSION: string = PACKAGE_JSON.version;

package/src/cli/parse-argv.ts

@@ -0,0 +1,52 @@
+import yargs from 'yargs';
+import { Config, DEFAULT_BASE_CONFIG } from '../core.js';
+import { VERSION } from './package.js';
+
+/** Parse argv into the config object of eslint-interactive */
+export function parseArgv(argv: string[]): Config {
+  const parsedArgv = yargs(argv.slice(2))
+    .version(VERSION)
+    .usage('$0 [file.js] [dir]')
+    .option('rulesdir', {
+      type: 'array',
+      describe: 'Use additional rules from this directory',
+    })
+    .nargs('rulesdir', 1)
+    .option('ext', {
+      type: 'array',
+      describe: 'Specify JavaScript file extensions',
+    })
+    .nargs('ext', 1)
+    .option('format', {
+      type: 'string',
+      describe: 'Specify the format to be used for the `Display problem messages` action',
+      default: DEFAULT_BASE_CONFIG.formatterName,
+    })
+    .option('cache', {
+      type: 'boolean',
+      describe: 'Only check changed files',
+      default: DEFAULT_BASE_CONFIG.cache,
+    })
+    .option('cache-location', {
+      type: 'string',
+      describe: `Path to the cache file or directory`,
+      default: DEFAULT_BASE_CONFIG.cacheLocation,
+    }).argv;
+  // NOTE: convert `string` type because yargs convert `'10'` (`string` type) into `10` (`number` type)
+  // and `lintFiles` only accepts `string[]`.
+  const patterns = parsedArgv._.map((pattern) => pattern.toString());
+  const rulePaths = parsedArgv.rulesdir?.map((rulePath) => rulePath.toString());
+  const extensions = parsedArgv.ext
+    ?.map((extension) => extension.toString())
+    // map '.js,.ts' into ['.js', '.ts']
+    .flatMap((extension) => extension.split(','));
+  const formatterName = parsedArgv.format;
+  return {
+    patterns,
+    rulePaths,
+    extensions,
+    formatterName,
+    cache: parsedArgv.cache,
+    cacheLocation: parsedArgv['cache-location'],
+  };
+}

package/src/cli/prompt.ts

@@ -0,0 +1,205 @@
+/* istanbul ignore file */
+
+import enquirer from 'enquirer';
+import { ESLint } from 'eslint';
+import { takeRuleStatistics } from '../formatter/index.js';
+
+const { prompt } = enquirer;
+
+// When combined with worker, for some reason the enquirer grabs the SIGINT and the process continues to survive.
+// Therefore, the process is explicitly terminated.
+const onCancel = () => process.exit();
+
+/**
+ * The type that indicates what to do with the problems of selected rules.
+ */
+export type Action =
+  | 'printResultDetails'
+  | 'applyAutoFixes'
+  | 'disablePerLine'
+  | 'disablePerFile'
+  | 'applySuggestions'
+  | 'makeFixableAndFix'
+  | 'reselectRules';
+
+/**
+ * The type representing how to display the lint results.
+ *
+ * `withPager` means that the lint results will be displayed with a pager (like `less` command).
+ * `withoutPager` means that the lint results will be displayed without a pager.
+ */
+export type DisplayMode = 'withPager' | 'withoutPager';
+
+/**
+ * The type that represents what to do next.
+ */
+export type NextStep = 'fixOtherRules' | 'exit' | 'undoTheFix';
+
+/**
+ * Ask the user for the rule ids to which they want to apply the action.
+ * @param ruleIdsInResults The rule ids that are in the lint results.
+ * @returns The rule ids
+ */
+export async function promptToInputRuleIds(ruleIdsInResults: string[]): Promise<string[]> {
+  const { ruleIds } = await prompt<{ ruleIds: string[] }>([
+    {
+      name: 'ruleIds',
+      type: 'multiselect',
+      message: 'Which rules would you like to apply action?',
+      hint: 'Select all you want with <space> key.',
+      choices: ruleIdsInResults,
+      validate(value) {
+        return value.length === 0 ? `Select at least one rule with <space> key.` : true;
+      },
+      onCancel,
+    },
+  ]);
+  return ruleIds;
+}
+
+/**
+ * Ask the user what action they want to perform.
+ * @returns The action name
+ */
+export async function promptToInputAction(
+  results: ESLint.LintResult[],
+  selectedRuleIds: string[],
+  initialAction?: Action,
+): Promise<Action> {
+  const ruleStatistics = takeRuleStatistics(results).filter((ruleStatistic) =>
+    selectedRuleIds.includes(ruleStatistic.ruleId),
+  );
+  const foldedStatistics = ruleStatistics.reduce(
+    (a, b) => ({
+      isFixableCount: a.isFixableCount + b.isFixableCount,
+      hasSuggestionsCount: a.hasSuggestionsCount + b.hasSuggestionsCount,
+    }),
+    { isFixableCount: 0, hasSuggestionsCount: 0 },
+  );
+
+  const choices = [
+    { name: 'printResultDetails', message: '🔎 Display details of lint results' },
+    { name: 'applyAutoFixes', message: '🔧 Run `eslint --fix`', disabled: foldedStatistics.isFixableCount === 0 },
+    { name: 'disablePerLine', message: '🔧 Disable per line' },
+    { name: 'disablePerFile', message: '🔧 Disable 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' },
+  ];
+
+  const { action } = await prompt<{
+    action: Action;
+  }>([
+    {
+      name: 'action',
+      type: 'select',
+      message: 'Which action do you want to do?',
+      choices,
+      initial: choices.findIndex((choice) => choice.name === initialAction) ?? 0,
+      onCancel,
+    },
+  ]);
+  return action;
+}
+
+/**
+ * Ask the user how to display the lint results.
+ * @returns How to display
+ */
+export async function promptToInputDisplayMode(): Promise<DisplayMode> {
+  const { displayMode } = await prompt<{
+    displayMode: DisplayMode;
+  }>([
+    {
+      name: 'displayMode',
+      type: 'select',
+      message: 'What format do you want to display the problem message in?',
+      choices: [
+        { name: 'withPager', message: '↕️  Display with pager' },
+        { name: 'withoutPager', message: '📃 Display without pager' },
+      ],
+      onCancel,
+    },
+  ]);
+  return displayMode;
+}
+
+/**
+ * Ask the user a description to leave in disable comment.
+ * @returns The description
+ */
+export async function promptToInputDescription(): Promise<string | undefined> {
+  const { description } = await prompt<{
+    description: string;
+  }>([
+    {
+      name: 'description',
+      type: 'input',
+      message: 'Leave a code comment with your reason for disabling (Optional)',
+      onCancel,
+    },
+  ]);
+  return description === '' ? undefined : description;
+}
+
+/**
+ * Ask the user what to do next.
+ * @returns What to do next.
+ */
+export async function promptToInputWhatToDoNext(): Promise<NextStep> {
+  const { nextStep } = await prompt<{ nextStep: NextStep }>([
+    {
+      name: 'nextStep',
+      type: 'select',
+      message: "What's the next step?",
+      choices: [
+        { name: 'fixOtherRules', message: '🔧 Fix other rules' },
+        { name: 'undoTheFix', message: '↩️  Undo the fix' },
+        { name: 'exit', message: '💚 Exit' },
+      ],
+      onCancel,
+    },
+  ]);
+  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

@@ -0,0 +1,50 @@
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Worker } from 'worker_threads';
+import { wrap } from 'comlink';
+import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+import isInstalledGlobally = require('is-installed-globally');
+import { warn } from '../cli/log.js';
+import { parseArgv } from '../cli/parse-argv.js';
+import { SerializableCore } from '../core-worker.js';
+import { lint, selectAction, selectRuleIds, checkResults, NextScene } from '../scene/index.js';
+
+export type Options = {
+  argv: string[];
+};
+
+/**
+ * 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 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'));
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ProxiedCore = wrap<typeof SerializableCore>((nodeEndpoint as any)(worker));
+  const core = await new ProxiedCore(config);
+
+  let nextScene: NextScene = { name: 'lint' };
+  while (nextScene.name !== 'exit') {
+    if (nextScene.name === 'lint') {
+      nextScene = await lint(core);
+    } else if (nextScene.name === 'selectRuleIds') {
+      nextScene = await selectRuleIds(core, nextScene.args);
+    } else if (nextScene.name === 'selectAction') {
+      nextScene = await selectAction(core, nextScene.args);
+    } else if (nextScene.name === 'checkResults') {
+      nextScene = await checkResults(nextScene.args);
+    }
+  }
+  await worker.terminate();
+}

package/src/core-worker.ts

@@ -0,0 +1,66 @@
+import { parentPort, MessageChannel } from 'worker_threads';
+import { expose, proxy } from 'comlink';
+import nodeEndpoint from 'comlink/dist/esm/node-adapter.mjs';
+import { ESLint } from 'eslint';
+import { Core, Config } from './core.js';
+import { FixableMaker, SuggestionFilter } from './plugin/index.js';
+
+/**
+ * @file This is a wrapper module for using the Core API with comlink.
+ */
+
+if (parentPort === null) throw new Error('This module must be started on a worker.');
+
+/**
+ * This is a wrapper for using the Core API from comlink.
+ *
+ * The arguments of the methods wrapped in comlink must be serializable.
+ * The methods in this class are serializable versions of the Core API methods.
+ */
+export class SerializableCore {
+  readonly core: Core;
+  constructor(config: Config) {
+    this.core = new Core(config);
+  }
+  async lint(...args: Parameters<Core['lint']>): ReturnType<Core['lint']> {
+    return this.core.lint(...args);
+  }
+  formatResultSummary(...args: Parameters<Core['formatResultSummary']>): ReturnType<Core['formatResultSummary']> {
+    return this.core.formatResultSummary(...args);
+  }
+  async formatResultDetails(...args: Parameters<Core['formatResultDetails']>): ReturnType<Core['formatResultDetails']> {
+    return this.core.formatResultDetails(...args);
+  }
+  async applyAutoFixes(...args: Parameters<Core['applyAutoFixes']>): ReturnType<Core['applyAutoFixes']> {
+    return proxy(await this.core.applyAutoFixes(...args));
+  }
+  async disablePerLine(...args: Parameters<Core['disablePerLine']>): ReturnType<Core['disablePerLine']> {
+    return proxy(await this.core.disablePerLine(...args));
+  }
+  async disablePerFile(...args: Parameters<Core['disablePerFile']>): ReturnType<Core['disablePerFile']> {
+    return proxy(await this.core.disablePerFile(...args));
+  }
+  async applySuggestions(
+    results: ESLint.LintResult[],
+    ruleIds: string[],
+    filterScript: string,
+  ): ReturnType<Core['applySuggestions']> {
+    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']> {
+    const fixableMaker = eval(fixableMakerScript) as FixableMaker;
+    return proxy(await this.core.makeFixableAndFix(results, ruleIds, fixableMaker));
+  }
+}
+
+// workaround for https://github.com/GoogleChromeLabs/comlink/issues/466
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(globalThis as any).MessageChannel = MessageChannel;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+expose(SerializableCore, (nodeEndpoint as any)(parentPort));