🔧 chore: Sleep on it, then fix code

Author: masonmark

TscExecutionResult.ts

@@ -1,9 +1,70 @@
+/**
+ This structure encapsulates the output of `tsc` in a single run. Note that this structure is for the results regardless of whether `tsc` succeeded or failed. So, you may want to check `tscExitCode` to see if `tsc` succeeded (exit code 0) or failed (non-zero), depending what you want to do with the results. Although tsc emits diagnostics sometimes even when it fails, the results may be weird/incomplete in that case.
+ */
 export interface TscExecutionResult
 {
-  code: number;
-  checkTime: number;
+  /**
+   The exit code of `tsc`.
+   */
+  tscExitCode: number;
+
+  /**
+   Elapsed time in milliseconds, as perceived by the runtime executing `tsc` as a subprocess (e.g., Deno, Bun, Node, etc)
+   */
   elapsedMs: number;
+
+  /**
+   The standard output of `tsc`, as a string.
+   */
   stdout: string;
+
+  /**
+   The standard error of `tsc`, as a string.
+   */
   stderr: string;
+
+  /**
+   A string representation of the command line that was run to invoke `tsc`. E.g.:
+   ```
+   'npx tsc --strict true --target esnext /Volumes/HOHOHO/my-project/libs/ts/core/foo-auth/tsconfig.lib.json.ts --allowImportingTsExtensions --noEmit --extendedDiagnostics'
+   */
   tscCommand: string;
+
+  /**
+   A best-effort attempt to parse the diagnostics, if any, from `tsc`. May not be present if `tsc` emitted no diagnostics or if an error occurred while parsing the diagnostics. Example (as of 2025-02-18 and `tsc Version 5.8.0-dev.20250218`):
+
+   ```json
+     diagnostics: {
+    Files: "858",
+    "Lines of Library": "38846",
+    "Lines of Definitions": "75228",
+    "Lines of TypeScript": "15172",
+    "Lines of JavaScript": "0",
+    "Lines of JSON": "0",
+    "Lines of Other": "0",
+    Identifiers: "115591",
+    Symbols: "104179",
+    Types: "20856",
+    Instantiations: "12276",
+    "Memory used": "165137K",
+    "Assignability cache size": "7573",
+    "Identity cache size": "69",
+    "Subtype cache size": "274",
+    "Strict subtype cache size": "135",
+    "I/O Read time": "0.14s",
+    "Parse time": "0.19s",
+    "ResolveModule time": "0.40s",
+    "ResolveLibrary time": "0.01s",
+    "ResolveTypeReference time": "0.00s",
+    "Program time": "0.77s",
+    "Bind time": "0.10s",
+    "Check time": "0.29s",
+    "transformTime time": "0.23s",
+    "printTime time": "0.00s",
+    "Emit time": "0.00s",
+    "Total time": "1.17s"
+  }
+  ```
+   */
+  diagnostics: Record<string, string>;
 }

deno.jsonc

@@ -2,5 +2,5 @@
   "name": "@axhxrx/tsc-time",
   "version": "0.0.1",
   "exports": "./mod.ts",
-  "license": "MIT",
-}
+  "license": "MIT"
+}

dprint.jsonc

@@ -1,3 +1,3 @@
 {
   "extends": "https://jsr.io/@axhxrx/dprint-config/0.0.3/dprint.jsonc"
-}
+}

geTscCommandComponents.ts renamed to getTscCommandComponents.ts

@@ -1,3 +1,4 @@
-export function isDenoRuntime(): boolean {
+export function isDenoRuntime(): boolean
+{
   return typeof Deno !== 'undefined' && typeof Deno?.Command === 'function';
 }

isDenoRuntime.ts

@@ -1,74 +1,7 @@
 // Deno is our jam, but because we want this to run under Bun and Node also, lets use modly old `process` which they all support:
 import process from 'node:process';
 
-import { isDenoRuntime } from './isDenoRuntime.ts';
-import { parseDiagnostics } from './parseDiagnostics.ts';
-import { printErrorInfo } from './printErrorInfo.ts';
-import { runTscWithDeno } from './runTscWithDeno.ts';
-import { runTscWithNode } from './runTscWithNode.ts';
-import type { TscExecutionResult } from './TscExecutionResult.ts';
-
-type TscExecutionResultWithDiagnostics = TscExecutionResult & { diagnostics: Record<string, unknown> };
-
-export async function runTsc(file: string): Promise<TscExecutionResultWithDiagnostics>
-{
-  let result: TscExecutionResult;
-
-  if (isDenoRuntime())
-  {
-    result = await runTscWithDeno(file);
-  }
-  else
-  {
-    // This works for Bun, too, so no need to check for Bun.
-    result = await runTscWithNode(file);
-  }
-
-  if (result.code !== 0)
-  {
-    printErrorInfo(result);
-    process.exit(1);
-  }
-
-  if (!result.stdout)
-  {
-    printErrorInfo(result, 'tsc produced no output');
-    process.exit(11);
-  }
-
-  // Parse "Check time:"
-  const checkTimeLine = result.stdout
-    .split('\n')
-    .find((line) => line.includes('Check time'));
-
-  if (!checkTimeLine)
-  {
-    printErrorInfo(result, 'FATAL: wtf: cannot parse tsc output, probably a bug in this tool then... 🙄');
-    process.exit(21);
-  }
-
-  const match = checkTimeLine.match(/([\d.]+)s/);
-  if (!match)
-  {
-    printErrorInfo(result,
-      'FATAL: wtf: cannot parse checkTime from line: ' + checkTimeLine + '\n\nVery likely a bug in this tool... 🙄 ');
-    process.exit(31);
-  }
-
-  const checkTime = parseFloat(match[1]);
-
-  result = {
-    ...result,
-    checkTime,
-  };
-
-  const diagnostics = parseDiagnostics(result.stdout);
-
-  return {
-    ...result,
-    diagnostics,
-  };
-}
+import { runTsc } from './runTsc.ts';
 
 export async function main()
 {

main.ts

@@ -1,10 +1,10 @@
 /**
- Parse the tsc output to get the diagnostics as JSON.
+ Parse the `tsc` output to get the diagnostics as JSON.
  */
-export function parseDiagnostics(output: string): Record<string, unknown>
+export function parseDiagnostics(output: string): Record<string, string>
 {
   const lines = output.split('\n');
-  const diagnostics: Record<string, unknown> = {};
+  const diagnostics: Record<string, string> = {};
   let key: string | null = null;
 
   for (const line of lines)

parseDiagnostics.ts

@@ -2,11 +2,11 @@ import type { TscExecutionResult } from './TscExecutionResult.ts';
 
 export function printErrorInfo(result: TscExecutionResult, additionalInfo?: string): void
 {
-  const isTscError = result.code !== 0;
+  const isTscError = result.tscExitCode !== 0;
 
   if (isTscError)
   {
-    console.error(`tsc exited with exit code ${result.code}: ${result.stderr}`);
+    console.error(`tsc exited with exit code ${result.tscExitCode}: ${result.stderr}`);
   }
   else
   {

printErrorInfo.ts

@@ -1,44 +1,82 @@
-import { isBunRuntime } from './isBunRuntime.ts';
+// Deno is our jam, but because we want this to run under Bun and Node also, lets use modly old `process` which they all support:
+import process from 'node:process';
+
 import { isDenoRuntime } from './isDenoRuntime.ts';
-import { isNodeRuntime } from './isNodeRuntime.ts';
-import { TscExecutionResultWithDiagnostics } from './main.ts';
-import { parseDiagnostics } from './parseDiagnostics.ts';
 import { printErrorInfo } from './printErrorInfo.ts';
-import { runTscWithBun } from './runTscWithBun.ts';
 import { runTscWithDeno } from './runTscWithDeno.ts';
+import { runTscWithNode } from './runTscWithNode.ts';
 import type { TscExecutionResult } from './TscExecutionResult.ts';
 
-export async function runTsc(file: string): Promise<TscExecutionResultWithDiagnostics>
+/**
+ Run `tsc` on the given file, and return the result as a `TscExecutionResult`. In most cases, the result will be returned even if `tsc` fails. The `tsc` command is run as a subprocess and its output is parsed.
+
+ This should work under Deno, Node, or Bun. Other runtimes not tested, but would only work if they can run subprocesses in a Node-compatible way.
+
+ Example result:
+ ```ts
+{
+  tscExitCode: 0,
+  elapsedMs: 1576.915708,
+  stdout: "Files: <blah blah blah omitted>...",
+  stderr: "",
+  tscCommand: "npx tsc --strict true --target esnext --project /Volumes/SORACOM/ucm-main/libs/ts/core/data-access-auth/tsconfig.lib.json --allowImportingTsExtensions --noEmit --extendedDiagnostics",
+  diagnostics: {
+    Files: "858",
+    "Lines of Library": "39520",
+    "Lines of Definitions": "75228",
+    "Lines of TypeScript": "15172",
+    "Lines of JavaScript": "0",
+    "Lines of JSON": "0",
+    "Lines of Other": "0",
+    Identifiers: "116052",
+    Symbols: "104457",
+    Types: "20866",
+    Instantiations: "12276",
+    "Memory used": "168666K",
+    "Assignability cache size": "7573",
+    "Identity cache size": "69",
+    "Subtype cache size": "274",
+    "Strict subtype cache size": "135",
+    "I/O Read time": "0.18s",
+    "Parse time": "0.20s",
+    "ResolveModule time": "0.04s",
+    "ResolveLibrary time": "0.01s",
+    "ResolveTypeReference time": "0.00s",
+    "Program time": "0.48s",
+    "Bind time": "0.11s",
+    "Check time": "0.32s",
+    "transformTime time": "0.19s",
+    "printTime time": "0.00s",
+    "Emit time": "0.00s",
+    "Total time": "0.91s",
+  },
+}
+ ```
+ */
+export async function runTsc(file: string): Promise<TscExecutionResult>
 {
   let result: TscExecutionResult;
 
   if (isDenoRuntime())
   {
     result = await runTscWithDeno(file);
   }
-  else if (isBunRuntime())
-  {
-    result = await runTscWithBun(file);
-  }
-  else if (isNodeRuntime())
-  {
-    result = await runTscWithNode(file);
-  }
   else
   {
-    throw new Error('Unsupported runtime. Not Node, Deno, or Bun!');
+    // This works for Bun, too, so no need to check for Bun.
+    result = await runTscWithNode(file);
   }
 
-  if (result.code !== 0)
+  if (result.tscExitCode !== 0)
   {
-    console.error('The tsc command failed:');
-    console.log(result.stdout);
-    throw new Error(`tsc exited with code ${result.code}: ${result.stderr}`);
+    printErrorInfo(result);
+    process.exit(1);
   }
 
   if (!result.stdout)
   {
-    throw new Error('tsc produced no output');
+    printErrorInfo(result, 'tsc produced no output');
+    process.exit(11);
   }
 
   // Parse "Check time:"
@@ -49,28 +87,18 @@ export async function runTsc(file: string): Promise<TscExecutionResultWithDiagno
   if (!checkTimeLine)
   {
     printErrorInfo(result, 'FATAL: wtf: cannot parse tsc output, probably a bug in this tool then... 🙄');
-    Deno.exit(1);
+    process.exit(21);
   }
 
   const match = checkTimeLine.match(/([\d.]+)s/);
   if (!match)
   {
-    printErrorInfo(result,
-      'FATAL: wtf: cannot parse checkTime from line: ' + checkTimeLine + '\n\nVery likely a bug in this tool... 🙄 ');
-    Deno.exit(1);
+    printErrorInfo(
+      result,
+      'FATAL: wtf: cannot parse checkTime from line: ' + checkTimeLine + '\n\nVery likely a bug in this tool... 🙄 ',
+    );
+    process.exit(31);
   }
 
-  const checkTime = parseFloat(match[1]);
-
-  result = {
-    ...result,
-    checkTime,
-  };
-
-  const diagnostics = parseDiagnostics(result.stdout);
-
-  return {
-    ...result,
-    diagnostics,
-  };
+  return result;
 }

runTsc.ts

@@ -1,28 +1,31 @@
-import { getTscCommandComponents } from './geTscCommandComponents.ts';
-import { TscExecutionResult } from './TscExecutionResult.ts';
+import { getTscCommandComponents } from './getTscCommandComponents.ts';
+import { parseDiagnostics } from './parseDiagnostics.ts';
+import type { TscExecutionResult } from './TscExecutionResult.ts';
 
+/**
+ The Deno flavor of `runTsc`.
+ */
 export async function runTscWithDeno(file: string): Promise<TscExecutionResult>
 {
   const start = performance.now();
 
-  let code = -1;
-  let rawStdout = new Uint8Array();
-  let rawStderr = new Uint8Array();
+  let tscExitCode = -1;
   const args = getTscCommandComponents(file, false);
   const command = new Deno.Command('npx', { args });
 
   const commandResult = await command.output();
-  code = commandResult.code;
-  rawStdout = commandResult.stdout;
-  rawStderr = commandResult.stderr;
+  tscExitCode = commandResult.code;
+  const stdout = new TextDecoder().decode(commandResult.stdout);
+  const stderr = new TextDecoder().decode(commandResult.stderr);
+  const diagnostics = parseDiagnostics(stdout);
 
   const result: TscExecutionResult = {
-    code,
-    checkTime: -1,
+    tscExitCode,
     elapsedMs: performance.now() - start,
-    stdout: new TextDecoder().decode(rawStdout),
-    stderr: new TextDecoder().decode(rawStderr),
+    stdout,
+    stderr,
     tscCommand: 'npx ' + args.join(' '),
+    diagnostics,
   };
 
   return result;