Expose CLI renderer

.changeset/nervous-carrots-yell.md

@@ -0,0 +1,5 @@
+---
+"@arethetypeswrong/cli": patch
+---
+
+Expose internal renderer and exit code API

packages/cli/package.json

@@ -21,11 +21,17 @@
   },
   "files": [
     "LICENSE",
-    "dist/**/*.js"
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts"
   ],
   "bin": {
     "attw": "./dist/index.js"
   },
+  "exports": {
+    "./internal/getExitCode": "./dist/getExitCode.js",
+    "./internal/render": "./dist/render/index.js"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -42,8 +48,8 @@
     "@types/marked-terminal": "^3.1.3",
     "@types/node": "^20.2.5",
     "@types/semver": "^7.5.3",
-    "ts-expose-internals": "5.3.2",
-    "typescript": "5.3.2"
+    "ts-expose-internals-conditionally": "1.0.0-empty.0",
+    "typescript": "5.3.3"
   },
   "dependencies": {
     "@arethetypeswrong/core": "0.13.6",

packages/cli/src/getExitCode.ts

@@ -0,0 +1,13 @@
+import type { CheckResult } from "@arethetypeswrong/core";
+import { problemFlags } from "./problemUtils.js";
+import type { RenderOptions } from "./render/index.js";
+
+export function getExitCode(analysis: CheckResult, opts?: RenderOptions): number {
+  if (!analysis.types) {
+    return 0;
+  }
+  if (!opts?.ignoreRules) {
+    return analysis.problems.length > 0 ? 1 : 0;
+  }
+  return analysis.problems.some((problem) => !opts.ignoreRules!.includes(problemFlags[problem.kind])) ? 1 : 0;
+}

packages/cli/src/index.ts

@@ -14,25 +14,25 @@ import { problemFlags } from "./problemUtils.js";
 import { readConfig } from "./readConfig.js";
 import * as render from "./render/index.js";
 import { major, minor } from "semver";
+import { getExitCode } from "./getExitCode.js";
 
 const packageJson = createRequire(import.meta.url)("../package.json");
 const version = packageJson.version;
 
-const formats = ["auto", "table", "table-flipped", "ascii", "json"] as const;
+const formats = Object.keys({
+  auto: true,
+  json: true,
+  ascii: true,
+  table: true,
+  "table-flipped": true,
+} satisfies Record<render.Format, any>) as render.Format[];
 
-type Format = (typeof formats)[number];
-
-export interface Opts {
+interface Opts extends render.RenderOptions {
   pack?: boolean;
   fromNpm?: boolean;
   definitelyTyped?: boolean | string;
-  summary?: boolean;
-  emoji?: boolean;
-  color?: boolean;
   quiet?: boolean;
   configPath?: string;
-  ignoreRules?: string[];
-  format: Format;
 
   entrypoints?: string[];
   includeEntrypoints?: string[];
@@ -81,9 +81,6 @@ particularly ESM-related module resolution issues.`,
   .action(async (fileOrDirectory = ".") => {
     const opts = program.opts<Opts>();
     await readConfig(program, opts.configPath);
-    opts.ignoreRules = opts.ignoreRules?.map(
-      (value) => Object.keys(problemFlags).find((key) => problemFlags[key as core.ProblemKind] === value) as string,
-    );
 
     if (opts.quiet) {
       console.log = () => {};
@@ -210,21 +207,24 @@ particularly ESM-related module resolution issues.`,
 
       console.log(JSON.stringify(result));
 
-      if (analysis.types && analysis.problems.some((problem) => !opts.ignoreRules?.includes(problem.kind)))
-        process.exit(1);
+      if (deleteTgz) {
+        await unlink(deleteTgz);
+      }
+
+      const exitCode = getExitCode(analysis, opts);
+      if (exitCode) {
+        process.exit(exitCode);
+      }
 
       return;
     }
 
     console.log();
     if (analysis.types) {
-      await render.typed(analysis, opts);
-
-      if (analysis.types && analysis.problems.some((problem) => !opts.ignoreRules?.includes(problem.kind))) {
-        process.exitCode = 1;
-      }
+      console.log(await render.typed(analysis, opts));
+      process.exitCode = getExitCode(analysis, opts);
     } else {
-      render.untyped(analysis as core.UntypedResult);
+      console.log(render.untyped(analysis as core.UntypedResult));
     }
 
     if (deleteTgz) {

packages/cli/src/problemUtils.ts

@@ -1,7 +1,7 @@
 import * as core from "@arethetypeswrong/core";
 import type { ProblemKind } from "@arethetypeswrong/core";
 
-export const problemFlags: Record<ProblemKind, string> = {
+export const problemFlags = {
   NoResolution: "no-resolution",
   UntypedResolution: "untyped-resolution",
   FalseCJS: "false-cjs",
@@ -13,7 +13,7 @@ export const problemFlags: Record<ProblemKind, string> = {
   MissingExportEquals: "missing-export-equals",
   UnexpectedModuleSyntax: "unexpected-module-syntax",
   InternalResolutionError: "internal-resolution-error",
-};
+} as const satisfies Record<ProblemKind, string>;
 
 export const resolutionKinds: Record<core.ResolutionKind, string> = {
   node10: "node10",

packages/cli/src/render/index.ts

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

packages/cli/src/render/typed.ts

@@ -1,48 +1,44 @@
 import * as core from "@arethetypeswrong/core";
+import { filterProblems, problemAffectsEntrypoint, problemKindInfo } from "@arethetypeswrong/core/problems";
 import { allResolutionKinds, getResolutionOption, groupProblemsByKind } from "@arethetypeswrong/core/utils";
 import chalk from "chalk";
 import Table, { type GenericTable, type HorizontalTableRow } from "cli-table3";
 import { marked } from "marked";
-
-import { filterProblems, problemAffectsEntrypoint, problemKindInfo } from "@arethetypeswrong/core/problems";
-import type { Opts } from "../index.js";
+import TerminalRenderer from "marked-terminal";
 import { moduleKinds, problemFlags, resolutionKinds } from "../problemUtils.js";
 import { asciiTable } from "./asciiTable.js";
-import TerminalRenderer from "marked-terminal";
+import type { RenderOptions } from "./index.js";
 
-export async function typed(analysis: core.Analysis, opts: Opts) {
-  const problems = analysis.problems.filter((problem) => !opts.ignoreRules || !opts.ignoreRules.includes(problem.kind));
+export async function typed(analysis: core.Analysis, opts: RenderOptions): Promise<string> {
+  let output = "";
+  const problems = analysis.problems.filter(
+    (problem) => !opts.ignoreRules || !opts.ignoreRules.includes(problemFlags[problem.kind]),
+  );
   const grouped = groupProblemsByKind(problems);
   const entrypoints = Object.keys(analysis.entrypoints);
   marked.setOptions({
     renderer: new TerminalRenderer(),
   });
 
-  console.log(`${analysis.packageName} v${analysis.packageVersion}`);
+  out(`${analysis.packageName} v${analysis.packageVersion}`);
   if (analysis.types.kind === "@types") {
-    console.log(`${analysis.types.packageName} v${analysis.types.packageVersion}`);
+    out(`${analysis.types.packageName} v${analysis.types.packageVersion}`);
   }
-  console.log();
+  out();
   if (Object.keys(analysis.buildTools).length) {
-    console.log("Build tools:");
-    console.log(
+    out("Build tools:");
+    out(
       Object.entries(analysis.buildTools)
         .map(([tool, version]) => {
           return `- ${tool}@${version}`;
         })
         .join("\n"),
     );
-    console.log();
+    out();
   }
 
   if (opts.ignoreRules && opts.ignoreRules.length) {
-    console.log(
-      chalk.gray(
-        ` (ignoring rules: ${opts.ignoreRules
-          .map((rule) => `'${problemFlags[rule as core.ProblemKind]}'`)
-          .join(", ")})\n`,
-      ),
-    );
+    out(chalk.gray(` (ignoring rules: ${opts.ignoreRules.map((rule) => `'${rule}'`).join(", ")})\n`));
   }
 
   if (opts.summary) {
@@ -54,7 +50,7 @@ export async function typed(analysis: core.Analysis, opts: Opts) {
       return `${emoji}${description}`;
     });
 
-    console.log(summaryTexts.join("") || defaultSummary);
+    out(summaryTexts.join("") || defaultSummary);
   }
 
   const entrypointNames = entrypoints.map(
@@ -119,25 +115,31 @@ export async function typed(analysis: core.Analysis, opts: Opts) {
 
   switch (opts.format) {
     case "table":
-      console.log(table!.toString());
+      out(table!.toString());
       break;
     case "table-flipped":
-      console.log(flippedTable!.toString());
+      out(flippedTable!.toString());
       break;
     case "ascii":
-      console.log(asciiTable(table!));
+      out(asciiTable(table!));
       break;
     case "auto":
       const terminalWidth = process.stdout.columns || 133; // This looks like GitHub Actions' width
       if (table!.width <= terminalWidth) {
-        console.log(table!.toString());
+        out(table!.toString());
       } else if (flippedTable!.width <= terminalWidth) {
-        console.log(flippedTable!.toString());
+        out(flippedTable!.toString());
       } else {
-        console.log(asciiTable(table!));
+        out(asciiTable(table!));
       }
       break;
   }
+
+  return output.trimEnd();
+
+  function out(s: string = "") {
+    output += s + "\n";
+  }
 }
 
 function memo<Args extends (string | number)[], Result>(fn: (...args: Args) => Result): (...args: Args) => Result {

packages/cli/src/render/untyped.ts

@@ -1,5 +1,5 @@
 import * as core from "@arethetypeswrong/core";
 
 export function untyped(analysis: core.UntypedResult) {
-  console.log("This package does not contain types.\nDetails: ", analysis);
+  return "This package does not contain types.\nDetails: " + JSON.stringify(analysis, null, 2);
 }

packages/cli/test/snapshots/ejs@3.1.9.tgz.md

@@ -5,7 +5,11 @@ $ attw [email protected] -f table-flipped
 
 
 This package does not contain types.
-Details:  { packageName: 'ejs', packageVersion: '3.1.9', types: false }
+Details: {
+  "packageName": "ejs",
+  "packageVersion": "3.1.9",
+  "types": false
+}
 
 
 ```

packages/cli/tsconfig.json

@@ -3,9 +3,8 @@
   "compilerOptions": {
     "module": "nodenext",
     "rootDir": "src",
-    "types": ["ts-expose-internals", "node"],
+    "types": ["ts-expose-internals-conditionally", "node"],
     "outDir": "./dist",
-    "declarationDir": "./lib",
     "sourceMap": true
   },
   "include": ["src"],