eslint-interactive 13.0.0 → 14.0.0

package/src/cli/prompt.ts

@@ -1,15 +1,16 @@
 /* istanbul ignore file */
 
-import enquirer from 'enquirer';
+import { isCancel, multiselect, select, text } from '@clack/prompts';
 import type { 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.
-// eslint-disable-next-line n/no-process-exit
-const onCancel = () => process.exit();
+function exitIfCancel<T>(value: T | symbol): T {
+  if (isCancel(value)) {
+    // eslint-disable-next-line n/no-process-exit
+    process.exit();
+  }
+  return value;
+}
 
 /**
  * The type that indicates what to do with the problems of selected rules.
@@ -45,21 +46,13 @@ export type DescriptionPosition = 'sameLine' | 'previousLine';
  * @returns The rule ids
  */
 export async function promptToInputRuleIds(ruleIdsInResults: string[]): Promise<string[]> {
-  const { ruleIds } = await prompt<{ ruleIds: string[] }>([
-    {
-      name: 'ruleIds',
-      type: 'multiselect',
+  return exitIfCancel(
+    await multiselect<string>({
       message: 'Which rules would you like to apply action?',
-      // @ts-expect-error
-      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;
+      options: ruleIdsInResults.map((ruleId) => ({ value: ruleId })),
+      required: true,
+    }),
+  );
 }
 
 /**
@@ -81,29 +74,21 @@ export async function promptToInputAction(
     { isFixableCount: 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: 'convertErrorToWarningPerFile', message: '🔧 Convert error to warning per file' },
-    { name: 'relintAndReselectRules', message: '↩️ Go back (with re-lint)' },
-    { name: 'reselectRules', message: '↩️ Go back' },
-  ];
-
-  const { action } = await prompt<{
-    action: Action;
-  }>([
-    {
-      name: 'action',
-      type: 'select',
+  return exitIfCancel(
+    await select<Action>({
       message: 'Which action do you want to do?',
-      choices,
-      initial: choices.findIndex((choice) => choice.name === initialAction) ?? 0,
-      onCancel,
-    },
-  ]);
-  return action;
+      options: [
+        { value: 'printResultDetails', label: '🔎 Display details of lint results' },
+        { value: 'applyAutoFixes', label: '🔧 Run `eslint --fix`', disabled: foldedStatistics.isFixableCount === 0 },
+        { value: 'disablePerLine', label: '🔧 Disable per line' },
+        { value: 'disablePerFile', label: '🔧 Disable per file' },
+        { value: 'convertErrorToWarningPerFile', label: '🔧 Convert error to warning per file' },
+        { value: 'relintAndReselectRules', label: '↩️ Go back (with re-lint)' },
+        { value: 'reselectRules', label: '↩️ Go back' },
+      ],
+      initialValue: initialAction,
+    }),
+  );
 }
 
 /**
@@ -111,22 +96,16 @@ export async function promptToInputAction(
  * @returns How to display
  */
 export async function promptToInputDisplayMode(): Promise<DisplayMode> {
-  const { displayMode } = await prompt<{
-    displayMode: DisplayMode;
-  }>([
-    {
-      name: 'displayMode',
-      type: 'select',
+  return exitIfCancel(
+    await select<DisplayMode>({
       message: 'In what way are the details displayed?',
-      choices: [
-        { name: 'printInTerminal', message: '🖨  Print in terminal' },
-        { name: 'printInTerminalWithPager', message: '↕️  Print in terminal with pager' },
-        { name: 'writeToFile', message: '📝 Write to file' },
+      options: [
+        { value: 'printInTerminal', label: '🖨  Print in terminal' },
+        { value: 'printInTerminalWithPager', label: '↕️  Print in terminal with pager' },
+        { value: 'writeToFile', label: '📝 Write to file' },
       ],
-      onCancel,
-    },
-  ]);
-  return displayMode;
+    }),
+  );
 }
 
 /**
@@ -134,17 +113,12 @@ export async function promptToInputDisplayMode(): Promise<DisplayMode> {
  * @returns The description
  */
 export async function promptToInputDescription(): Promise<string | undefined> {
-  const { description } = await prompt<{
-    description: string;
-  }>([
-    {
-      name: 'description',
-      type: 'input',
+  const description = exitIfCancel(
+    await text({
       message: 'Leave a code comment with your reason for fixing (Optional)',
-      onCancel,
-    },
-  ]);
-  return description === '' ? undefined : description;
+    }),
+  );
+  return description.trim() === '' ? undefined : description.trim();
 }
 
 /**
@@ -152,21 +126,15 @@ export async function promptToInputDescription(): Promise<string | undefined> {
  * @returns The description position
  */
 export async function promptToInputDescriptionPosition(): Promise<DescriptionPosition> {
-  const { descriptionPosition } = await prompt<{
-    descriptionPosition: DescriptionPosition;
-  }>([
-    {
-      name: 'descriptionPosition',
-      type: 'select',
+  return exitIfCancel(
+    await select<DescriptionPosition>({
       message: 'Where would you like to position the code comment?',
-      choices: [
-        { name: 'sameLine', message: "Same Line - Place on the same line as the eslint's disable comment." },
-        { name: 'previousLine', message: "Previous Line - Place on the line before the eslint's disable comment." },
+      options: [
+        { value: 'sameLine', label: "Same Line - Place on the same line as the eslint's disable comment." },
+        { value: 'previousLine', label: "Previous Line - Place on the line before the eslint's disable comment." },
       ],
-      onCancel,
-    },
-  ]);
-  return descriptionPosition;
+    }),
+  );
 }
 
 /**
@@ -174,18 +142,14 @@ export async function promptToInputDescriptionPosition(): Promise<DescriptionPos
  * @returns What to do next.
  */
 export async function promptToInputWhatToDoNext(): Promise<NextStep> {
-  const { nextStep } = await prompt<{ nextStep: NextStep }>([
-    {
-      name: 'nextStep',
-      type: 'select',
+  return exitIfCancel(
+    await select<NextStep>({
       message: "What's the next step?",
-      choices: [
-        { name: 'fixOtherRules', message: '🔧 Fix other rules' },
-        { name: 'undoTheFix', message: '↩️  Undo the fix' },
-        { name: 'exit', message: '💚 Exit' },
+      options: [
+        { value: 'fixOtherRules', label: '🔧 Fix other rules' },
+        { value: 'undoTheFix', label: '↩️  Undo the fix' },
+        { value: 'exit', label: '💚 Exit' },
       ],
-      onCancel,
-    },
-  ]);
-  return nextStep;
+    }),
+  );
 }

package/src/cli/run.ts

@@ -1,11 +1,5 @@
-import { dirname, join } from 'node:path';
-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 terminalLink from 'terminal-link';
 import { parseArgv } from '../cli/parse-argv.js';
-import type { SerializableCore } from '../core-worker.js';
+import { Core } from '../core.js';
 import type { NextScene } from '../scene/index.js';
 import { checkResults, lint, selectAction, selectRuleIds } from '../scene/index.js';
 
@@ -13,29 +7,10 @@ export type Options = {
   argv: string[];
 };
 
-/**
- * Run eslint-interactive.
- */
+/** Run eslint-interactive. */
 export async function run(options: Options) {
   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: {
-      // 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,
-  });
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const ProxiedCore = wrap<typeof SerializableCore>((nodeEndpoint as any)(worker));
-  const core = await new ProxiedCore(config);
+  const core = new Core(config);
 
   let nextScene: NextScene = { name: 'lint' };
   while (nextScene.name !== 'exit') {
@@ -53,5 +28,4 @@ export async function run(options: Options) {
       nextScene = await checkResults(nextScene.args);
     }
   }
-  await worker.terminate();
 }

package/src/core.ts

@@ -12,9 +12,9 @@ import {
   createFixToMakeFixableAndFix,
   verifyAndFix,
 } from './fix/index.js';
-import { format, sortRuleStatistics, takeRuleStatistics } from './formatter/index.js';
+import { filterRuleStatistics, format, sortRuleStatistics, takeRuleStatistics } from './formatter/index.js';
 import { plugin } from './plugin.js';
-import type { Config, SortField, SortOrder } from './type.js';
+import type { Config, FilterCriterion, SortField, SortOrder } from './type.js';
 import { filterResultsByRuleId } from './util/eslint.js';
 
 /**
@@ -42,6 +42,7 @@ export class Core {
   readonly #formatterName: string | undefined;
   readonly #sort: SortField | undefined;
   readonly #sortOrder: SortOrder | undefined;
+  readonly #filters: FilterCriterion[] | undefined;
   readonly #eslint: ESLint;
 
   constructor(config: Config) {
@@ -51,10 +52,11 @@ export class Core {
     this.#formatterName = config.formatterName;
     this.#sort = config.sort;
     this.#sortOrder = config.sortOrder;
+    this.#filters = config.filters;
 
     // 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 { formatterName, patterns, quiet, sort, sortOrder, filters, ...eslintOptions } = config;
     const overrideConfigs =
       Array.isArray(eslintOptions.overrideConfig) ? eslintOptions.overrideConfig
       : eslintOptions.overrideConfig ? [eslintOptions.overrideConfig]
@@ -89,15 +91,20 @@ export class Core {
    */
   formatResultSummary(results: ESLint.LintResult[]): string {
     const rulesMeta = this.#eslint.getRulesMetaForResults(results);
-    return format(results, { rulesMeta, cwd: this.#cwd }, { sort: this.#sort, sortOrder: this.#sortOrder });
+    return format(
+      results,
+      { rulesMeta, cwd: this.#cwd },
+      { sort: this.#sort, sortOrder: this.#sortOrder, filters: this.#filters },
+    );
   }
 
   /**
-   * Returns ruleIds from lint results, sorted according to the configured sort options.
+   * Returns ruleIds from lint results, filtered and sorted according to the configured options.
    * @param results The lint results of the project
    */
-  getSortedRuleIdsInResults(results: ESLint.LintResult[]): string[] {
+  getFilteredAndSortedRuleIds(results: ESLint.LintResult[]): string[] {
     let ruleStatistics = takeRuleStatistics(results);
+    ruleStatistics = filterRuleStatistics(ruleStatistics, this.#filters);
     if (this.#sort) {
       ruleStatistics = sortRuleStatistics(ruleStatistics, this.#sort, this.#sortOrder);
     }

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

@@ -1,5 +1,5 @@
 import type { Rule, SourceCode } from 'eslint';
-import type { DescriptionPosition } from 'src/cli/prompt.js';
+import type { DescriptionPosition } from '../cli/prompt.js';
 import { mergeFixes } from '../eslint/report-translator.js';
 import { unique } from '../util/array.js';
 import type { DisableComment } from '../util/eslint.js';

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

@@ -1,5 +1,5 @@
 import type { Linter, Rule, SourceCode } from 'eslint';
-import type { DescriptionPosition } from 'src/cli/prompt.js';
+import type { DescriptionPosition } from '../cli/prompt.js';
 import { mergeFixes } from '../eslint/report-translator.js';
 import { groupBy, unique } from '../util/array.js';
 import type { DisableComment } from '../util/eslint.js';

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

@@ -0,0 +1,27 @@
+import type { FilterCriterion } from '../type.js';
+import { unreachable } from '../util/type-check.js';
+import type { RuleStatistic } from './take-rule-statistics.js';
+
+function matchesCriterion(statistic: RuleStatistic, criterion: FilterCriterion): boolean {
+  switch (criterion) {
+    case 'fixable':
+      return statistic.isFixableCount > 0;
+    case 'has-suggestions':
+      return statistic.hasSuggestionsCount > 0;
+    default:
+      return unreachable(`Invalid filter criterion: ${criterion as string}`);
+  }
+}
+
+/**
+ * Filter rule statistics by the given criteria.
+ * Multiple criteria are OR-ed together; a statistic is kept if it matches any of them.
+ * When `criteria` is undefined or empty, the input is returned unchanged.
+ */
+export function filterRuleStatistics(
+  statistics: RuleStatistic[],
+  criteria: readonly FilterCriterion[] | undefined,
+): RuleStatistic[] {
+  if (!criteria || criteria.length === 0) return statistics;
+  return statistics.filter((statistic) => criteria.some((criterion) => matchesCriterion(statistic, criterion)));
+}

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

@@ -1,9 +1,10 @@
 // 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 type { FilterCriterion, SortField, SortOrder } from '../type.js';
+import { terminalLink } from '../util/terminal-link.js';
 import { ERROR_COLOR } from './colors.js';
+import { filterRuleStatistics } from './filter-rule-statistics.js';
 import { formatTable } from './format-table.js';
 import { sortRuleStatistics } from './sort-rule-statistics.js';
 import { takeRuleStatistics } from './take-rule-statistics.js';
@@ -18,9 +19,10 @@ type Row = [
   hasSuggestionsCount: string,
 ];
 
-export type FormatByRulesSortOptions = {
+export type FormatByRulesOptions = {
   sort?: SortField | undefined;
   sortOrder?: SortOrder | undefined;
+  filters?: FilterCriterion[] | undefined;
 };
 
 function numCell(num: number): string {
@@ -30,11 +32,12 @@ function numCell(num: number): string {
 export function formatByRules(
   results: ESLint.LintResult[],
   data?: ESLint.LintResultData,
-  sortOptions?: FormatByRulesSortOptions,
+  options?: FormatByRulesOptions,
 ): string {
   let ruleStatistics = takeRuleStatistics(results);
-  if (sortOptions?.sort) {
-    ruleStatistics = sortRuleStatistics(ruleStatistics, sortOptions.sort, sortOptions.sortOrder);
+  ruleStatistics = filterRuleStatistics(ruleStatistics, options?.filters);
+  if (options?.sort) {
+    ruleStatistics = sortRuleStatistics(ruleStatistics, options.sort, options.sortOrder);
   }
 
   const rows: Row[] = [];
@@ -42,7 +45,7 @@ export function formatByRules(
     const { ruleId, errorCount, warningCount, isFixableCount, hasSuggestionsCount } = ruleStatistic;
     const ruleMetaData = data?.rulesMeta[ruleId];
     rows.push([
-      ruleMetaData?.docs?.url ? terminalLink(ruleId, ruleMetaData?.docs.url, { fallback: false }) : ruleId,
+      ruleMetaData?.docs?.url ? terminalLink(ruleId, ruleMetaData?.docs.url) : ruleId,
       numCell(errorCount),
       numCell(warningCount),
       numCell(isFixableCount),

package/src/formatter/index.ts

@@ -1,14 +1,15 @@
 import type { ESLint } from 'eslint';
 import { formatByFiles } from './format-by-files.js';
-import { formatByRules, type FormatByRulesSortOptions } from './format-by-rules.js';
+import { formatByRules, type FormatByRulesOptions } from './format-by-rules.js';
 
 export { takeRuleStatistics, type RuleStatistic } from './take-rule-statistics.js';
 export { sortRuleStatistics } from './sort-rule-statistics.js';
+export { filterRuleStatistics } from './filter-rule-statistics.js';
 
 export function format(
   results: ESLint.LintResult[],
   data?: ESLint.LintResultData,
-  sortOptions?: FormatByRulesSortOptions,
+  options?: FormatByRulesOptions,
 ): string {
-  return `${formatByFiles(results)}\n${formatByRules(results, data, sortOptions)}`;
+  return `${formatByFiles(results)}\n${formatByRules(results, data, options)}`;
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 export { run, type Options } from './cli/run.js';
 export { Core } from './core.js';
-export { type SortField, type SortOrder, type Config } from './type.js';
+export { type SortField, type SortOrder, type FilterCriterion, type Config } from './type.js';
 export { takeRuleStatistics, type RuleStatistic, sortRuleStatistics } from './formatter/index.js';
 export { type FixableMaker, type SuggestionFilter, type FixContext } from './fix/index.js';

package/src/scene/check-results.ts

@@ -1,7 +1,7 @@
 import type { ESLint } from 'eslint';
+import { withProgress } from '../cli/log.js';
 import type { Action } from '../cli/prompt.js';
 import { promptToInputWhatToDoNext } from '../cli/prompt.js';
-import { undoingSpinner } from '../cli/spinner.js';
 import type { Undo } from '../core.js';
 import type { NextScene } from './index.js';
 
@@ -31,14 +31,11 @@ export async function checkResults({
   const nextStep = await promptToInputWhatToDoNext();
   if (nextStep === 'exit') return { name: 'exit' };
   if (nextStep === 'undoTheFix') {
-    await undoingSpinner(async () => undo());
+    await withProgress('Undoing', async () => undo());
     return {
       name: 'selectAction',
       args: { results, ruleIdsInResults, selectedRuleIds, initialAction: selectedAction },
     };
   }
-  console.log();
-  console.log('─'.repeat(process.stdout.columns));
-  console.log();
   return { name: 'lint' };
 }

package/src/scene/lint.ts

@@ -1,15 +1,13 @@
-import type { Remote } from 'comlink';
-import { error } from '../cli/log.js';
-import { lintingSpinner } from '../cli/spinner.js';
-import type { SerializableCore } from '../core-worker.js';
+import { log } from '@clack/prompts';
+import { error, withProgress } from '../cli/log.js';
+import type { Core } from '../core.js';
 import type { NextScene } from './index.js';
 
 /**
  * Run the scene to lint.
  */
-export async function lint(core: Remote<SerializableCore>): Promise<NextScene> {
-  const results = await lintingSpinner(async () => core.lint());
-  console.log();
+export async function lint(core: Core): Promise<NextScene> {
+  const results = await withProgress('Linting', async () => core.lint());
 
   // Check for ESLint core problems (ruleId === null) first.
   // These represent config errors, syntax errors, etc. that eslint-interactive cannot fix.
@@ -21,19 +19,23 @@ export async function lint(core: Remote<SerializableCore>): Promise<NextScene> {
         'Check the details of the problem and fix it. ' +
         'This is usually caused by the invalid eslint config or the invalid syntax of the linted code.',
     );
-    console.log(await core.formatResultDetails(results, [null]));
+    log.message(await core.formatResultDetails(results, [null]), {});
     // eslint-disable-next-line n/no-process-exit
     process.exit(1);
   }
 
-  const ruleIdsInResults = await core.getSortedRuleIdsInResults(results);
+  const ruleIdsInResults = core.getFilteredAndSortedRuleIds(results);
 
   if (ruleIdsInResults.length === 0) {
-    console.log('💚 No error found.');
+    const hasAnyMessage = results.some((result) => result.messages.length > 0);
+    if (hasAnyMessage) {
+      log.message('💚 No rules match the given --filter.');
+    } else {
+      log.message('💚 No rules with problems.');
+    }
     return { name: 'exit' };
   }
-  console.log(await core.formatResultSummary(results));
+  log.message(core.formatResultSummary(results));
 
-  console.log();
   return { name: 'selectRuleIds', args: { results, ruleIdsInResults } };
 }

package/src/scene/select-action.ts

@@ -1,4 +1,3 @@
-import type { Remote } from 'comlink';
 import type { ESLint } from 'eslint';
 import {
   doConvertErrorToWarningPerFileAction,
@@ -9,8 +8,7 @@ import {
 } from '../action/index.js';
 import type { Action } from '../cli/prompt.js';
 import { promptToInputAction } from '../cli/prompt.js';
-import type { Undo } from '../core.js';
-import type { SerializableCore } from '../core-worker.js';
+import type { Core, Undo } from '../core.js';
 import { unreachable } from '../util/type-check.js';
 import type { NextScene } from './index.js';
 
@@ -29,7 +27,7 @@ export type SelectActionArgs = {
  * Run the scene where a user select the action to be performed for the problems of selected rules.
  */
 export async function selectAction(
-  core: Remote<SerializableCore>,
+  core: Core,
   { results, ruleIdsInResults, selectedRuleIds, initialAction }: SelectActionArgs,
 ): Promise<NextScene> {
   const selectedAction = await promptToInputAction(results, selectedRuleIds, initialAction);

package/src/scene/select-rule-ids.ts

@@ -1,7 +1,6 @@
-import type { Remote } from 'comlink';
 import type { ESLint } from 'eslint';
 import { promptToInputRuleIds } from '../cli/prompt.js';
-import type { SerializableCore } from '../core-worker.js';
+import type { Core } from '../core.js';
 import type { NextScene } from './index.js';
 import { selectAction } from './select-action.js';
 
@@ -15,10 +14,7 @@ export type SelectRuleIdsArgs = {
 /**
  * Run the scene where a user select rule ids.
  */
-export async function selectRuleIds(
-  core: Remote<SerializableCore>,
-  { results, ruleIdsInResults }: SelectRuleIdsArgs,
-): Promise<NextScene> {
+export async function selectRuleIds(core: Core, { results, ruleIdsInResults }: SelectRuleIdsArgs): Promise<NextScene> {
   const selectedRuleIds = await promptToInputRuleIds(ruleIdsInResults);
   return selectAction(core, { results, ruleIdsInResults, selectedRuleIds });
 }

package/src/type.ts

@@ -2,6 +2,7 @@ import type { ESLint } from 'eslint';
 
 export type SortField = 'rule' | 'error' | 'warning' | 'fixable' | 'suggestions';
 export type SortOrder = 'asc' | 'desc';
+export type FilterCriterion = 'fixable' | 'has-suggestions';
 
 /** The config of eslint-interactive */
 export type Config = ESLint.Options & {
@@ -10,4 +11,5 @@ export type Config = ESLint.Options & {
   quiet?: boolean | undefined;
   sort?: SortField | undefined;
   sortOrder?: SortOrder | undefined;
+  filters?: FilterCriterion[] | undefined;
 };

package/src/util/terminal-link.ts

@@ -0,0 +1,16 @@
+const OSC = '\x1B]';
+const BEL = '\x07';
+
+function buildOsc8Link(text: string, url: string): string {
+  return `${OSC}8;;${url}${BEL}${text}${OSC}8;;${BEL}`;
+}
+
+function supportsHyperlinks(): boolean {
+  if (process.env['FORCE_HYPERLINK'] === '1') return true;
+  if (process.env['FORCE_HYPERLINK'] === '0') return false;
+  return process.stdout.isTTY;
+}
+
+export function terminalLink(text: string, url: string): string {
+  return supportsHyperlinks() ? buildOsc8Link(text, url) : text;
+}

package/src/cli/spinner.ts

@@ -1,22 +0,0 @@
-import { createSpinner } from 'nanospinner';
-
-export async function lintingSpinner<T>(cb: () => Promise<T>): Promise<T> {
-  const spinner = createSpinner('Linting...').start();
-  const result = await cb();
-  spinner.success();
-  return result;
-}
-
-export async function fixingSpinner<T>(cb: () => Promise<T>): Promise<T> {
-  const spinner = createSpinner('Fixing...').start();
-  const result = await cb();
-  spinner.success();
-  return result;
-}
-
-export async function undoingSpinner<T>(cb: () => Promise<T>): Promise<T> {
-  const spinner = createSpinner('Undoing...').start();
-  const result = await cb();
-  spinner.success();
-  return result;
-}