feat: ignore resolutions option

Add option to ignore resolution modes such as `Node10`.
Via config: `ignoreResolutions`
Via cli: `--ignoreResolutions`

Option to skip validation for Node10 #112

Author: jason-ha

.changeset/fuzzy-cats-shed.md

@@ -0,0 +1,5 @@
+---
+"@arethetypeswrong/core": minor
+---
+
+Add --ignore-resolutions cli option. Example: --ignore-resolutions node10

packages/cli/README.md

@@ -181,6 +181,25 @@ attw <file-name> --ignore-rules <rules...>
 
 In the config file, `ignoreRules` can be an array of strings.
 
+#### Ignore Resolutions
+
+Specifies resolution modes to ignore (i.e. do not evaluate).
+
+The available values are:
+
+- `node10`
+- `node16-cjs`
+- `node16-esm`
+- `bundler`
+
+In the CLI: `--ignore-resolutions`
+
+```shell
+attw <file-name> --ignore-resolutions <resolutions...>
+```
+
+In the config file, `ignoreResolutions` can be an array of strings.
+
 #### Summary/No Summary
 
 Whether to display a summary of what the different errors/problems mean. Defaults to showing the summary (`--summary`).

packages/cli/src/index.ts

@@ -10,7 +10,7 @@ import { readFile, stat, unlink } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
 import readline from "readline";
-import { problemFlags } from "./problemUtils.js";
+import { problemFlags, resolutionKinds } from "./problemUtils.js";
 import { readConfig } from "./readConfig.js";
 import * as render from "./render/index.js";
 import { major, minor } from "semver";
@@ -80,6 +80,11 @@ particularly ESM-related module resolution issues.`,
   .addOption(
     new Option("--ignore-rules <rules...>", "Specify rules to ignore").choices(Object.values(problemFlags)).default([]),
   )
+  .addOption(
+    new Option("--ignore-resolutions <resolutions...>", "Specify resolutions to ignore")
+      .choices(Object.keys(resolutionKinds))
+      .default([]),
+  )
   .option("--summary, --no-summary", "Whether to print summary information about the different errors")
   .option("--emoji, --no-emoji", "Whether to use any emojis")
   .option("--color, --no-color", "Whether to use any colors (the FORCE_COLOR env variable is also available)")

packages/cli/src/readConfig.ts

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { readFile } from "fs/promises";
-import { problemFlags } from "./problemUtils.js";
+import { problemFlags, resolutionKinds } from "./problemUtils.js";
 
 export async function readConfig(program: Command, alternate = ".attw.json") {
   try {
@@ -25,6 +25,17 @@ export async function readConfig(program: Command, alternate = ".attw.json") {
           );
       }
 
+      if (key === "ignoreResolutions") {
+        if (!Array.isArray(value)) program.error(`error: config option 'ignoreResolutions' should be an array.`);
+        const invalid = value.find((resolution) => !Object.keys(resolutionKinds).includes(resolution));
+        if (invalid)
+          program.error(
+            `error: config option 'ignoreResolutions' argument '${invalid}' is invalid. Allowed choices are ${Object.keys(
+              resolutionKinds,
+            ).join(", ")}.`,
+          );
+      }
+
       if (Array.isArray(value)) {
         const opt = program.getOptionValue(key);
 

packages/cli/src/render/index.ts

@@ -1,8 +1,9 @@
-import type { problemFlags } from "../problemUtils.js";
+import type { problemFlags, resolutionKinds } from "../problemUtils.js";
 
 export type Format = "auto" | "table" | "table-flipped" | "ascii" | "json";
 export interface RenderOptions {
   ignoreRules?: (typeof problemFlags)[keyof typeof problemFlags][];
+  ignoreResolutions?: (keyof typeof resolutionKinds)[];
   format?: Format;
   color?: boolean;
   summary?: boolean;

packages/cli/src/render/typed.ts

@@ -11,12 +11,13 @@ import type { RenderOptions } from "./index.js";
 
 export async function typed(
   analysis: core.Analysis,
-  { emoji = true, summary = true, format = "auto", ignoreRules = [] }: RenderOptions,
+  { emoji = true, summary = true, format = "auto", ignoreRules = [], ignoreResolutions = [] }: RenderOptions,
 ): Promise<string> {
   let output = "";
   const problems = analysis.problems.filter(
     (problem) => !ignoreRules || !ignoreRules.includes(problemFlags[problem.kind]),
   );
+  const resolutions = allResolutionKinds.filter((kind) => !ignoreResolutions.includes(kind));
   const grouped = groupProblemsByKind(problems);
   const entrypoints = Object.keys(analysis.entrypoints);
   marked.setOptions({
@@ -43,6 +44,11 @@ export async function typed(
   if (ignoreRules && ignoreRules.length) {
     out(chalk.gray(` (ignoring rules: ${ignoreRules.map((rule) => `'${rule}'`).join(", ")})\n`));
   }
+  if (ignoreResolutions && ignoreResolutions.length) {
+    out(
+      chalk.gray(` (ignoring resolutions: ${ignoreResolutions.map((resolution) => `'${resolution}'`).join(", ")})\n`),
+    );
+  }
 
   if (summary) {
     const defaultSummary = marked(!emoji ? " No problems found" : " No problems found 🌟");
@@ -93,14 +99,14 @@ export async function typed(
   const flippedTable =
     format === "auto" || format === "table-flipped"
       ? new Table({
-          head: ["", ...allResolutionKinds.map((kind) => chalk.reset(resolutionKinds[kind]))],
+          head: ["", ...resolutions.map((kind) => chalk.reset(resolutionKinds[kind]))],
         })
       : undefined;
   if (flippedTable) {
     entrypoints.forEach((subpath, i) => {
       flippedTable.push([
         entrypointHeaders[i],
-        ...allResolutionKinds.map((resolutionKind) => getCellContents(subpath, resolutionKind)),
+        ...resolutions.map((resolutionKind) => getCellContents(subpath, resolutionKind)),
       ]);
     });
   }
@@ -112,7 +118,7 @@ export async function typed(
         }) as GenericTable<HorizontalTableRow>)
       : undefined;
   if (table) {
-    allResolutionKinds.forEach((kind) => {
+    resolutions.forEach((kind) => {
       table.push([resolutionKinds[kind], ...entrypoints.map((entrypoint) => getCellContents(entrypoint, kind))]);
     });
   }