feat: use own CancellationToken class

.github/workflows/checks.yml

@@ -54,7 +54,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: ["16.14", "16.x", "18.x", "20.x", "21.x"]
+        node-version: ["16.0", "16.x", "18.x", "20.x", "21.x"]
     runs-on: ubuntu-latest
 
     steps:
@@ -78,7 +78,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, macOS-latest]
+        os: [macOS-latest, windows-latest]
     runs-on: ${{ matrix.os }}
 
     steps:

package.json

@@ -93,6 +93,6 @@
   },
   "packageManager": "yarn@3.8.0",
   "engines": {
-    "node": "^16.14 || 18.x || >=20.x"
+    "node": "16.x || 18.x || >=20.x"
   }
 }

source/api/TSTyche.ts

@@ -6,9 +6,10 @@ import { EventEmitter } from "#events";
 import { SummaryReporter, ThoroughReporter } from "#reporters";
 import { TaskRunner } from "#runner";
 import type { StoreService } from "#store";
+import { CancellationToken } from "#token";
 
 export class TSTyche {
-  #abortController = new AbortController();
+  #cancellationToken = new CancellationToken();
   #storeService: StoreService;
   #taskRunner: TaskRunner;
   static readonly version = "__version__";
@@ -32,7 +33,7 @@ export class TSTyche {
           process.exitCode = 1;
 
           if (this.resolvedConfig.failFast) {
-            this.#abortController.abort();
+            this.#cancellationToken.cancel();
           }
         }
       }
@@ -65,7 +66,7 @@ export class TSTyche {
     await this.#taskRunner.run(
       this.#normalizePaths(testFiles),
       this.resolvedConfig.target,
-      this.#abortController.signal,
+      this.#cancellationToken,
     );
   }
 }

source/cli/Cli.ts

@@ -7,8 +7,10 @@ import { EventEmitter, type EventHandler } from "#events";
 import { Logger } from "#logger";
 import { addsPackageStepText, diagnosticText, formattedText, helpText } from "#output";
 import { StoreService } from "#store";
+import { CancellationToken } from "#token";
 
 export class Cli {
+  #cancellationToken = new CancellationToken();
   #logger: Logger;
   #storeService: StoreService;
 
@@ -28,9 +30,10 @@ export class Cli {
         for (const diagnostic of payload.diagnostics) {
           switch (diagnostic.category) {
             case DiagnosticCategory.Error:
-              process.exitCode = 1;
-
+              this.#cancellationToken.cancel();
               this.#logger.writeError(diagnosticText(diagnostic));
+
+              process.exitCode = 1;
               break;
 
             case DiagnosticCategory.Warning:
@@ -86,13 +89,14 @@ export class Cli {
 
     await configService.parseCommandLine(commandLineArguments);
 
-    if (process.exitCode === 1) {
+    if (this.#cancellationToken.isCancellationRequested) {
       return;
     }
 
     await configService.readConfigFile();
 
-    if (process.exitCode === 1) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (this.#cancellationToken.isCancellationRequested) {
       return;
     }
 

source/diagnostic/Diagnostic.ts

@@ -60,21 +60,16 @@ export class Diagnostic {
   static fromError(text: string | Array<string>, error: unknown): Diagnostic {
     const messageText = Array.isArray(text) ? text : [text];
 
-    if (error instanceof Error) {
-      if (error.cause != null) {
-        messageText.push(this.#normalizeMessage(String(error.cause)));
+    if (error instanceof Error && error.stack != null) {
+      if (messageText.length > 1) {
+        messageText.push("");
       }
 
-      messageText.push(this.#normalizeMessage(String(error.message)));
+      const stackLines = error.stack
+        .split("\n")
+        .map((line) => line.trimStart());
 
-      if (error.stack != null) {
-        const stackLines = error.stack
-          .split("\n")
-          .slice(1)
-          .map((line) => line.trimStart());
-
-        messageText.push(...stackLines);
-      }
+      messageText.push(...stackLines);
     }
 
     return Diagnostic.error(messageText);
@@ -84,14 +79,6 @@ export class Diagnostic {
     return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
   }
 
-  static #normalizeMessage(text: string) {
-    if (text.endsWith(".")) {
-      return text;
-    }
-
-    return `${text}.`;
-  }
-
   static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic {
     return new Diagnostic(text, DiagnosticCategory.Warning, origin);
   }

source/runner/TaskRunner.ts

@@ -2,6 +2,7 @@ import type { ResolvedConfig } from "#config";
 import { EventEmitter } from "#events";
 import { Result, ResultManager, TargetResult } from "#result";
 import type { StoreService } from "#store";
+import type { CancellationToken } from "#token";
 import { TestFileRunner } from "./TestFileRunner.js";
 
 export class TaskRunner {
@@ -21,7 +22,7 @@ export class TaskRunner {
     });
   }
 
-  async run(testFiles: Array<URL>, target: Array<string>, signal?: AbortSignal): Promise<Result> {
+  async run(testFiles: Array<URL>, target: Array<string>, cancellationToken?: CancellationToken): Promise<Result> {
     const result = new Result(this.resolvedConfig, testFiles);
 
     EventEmitter.dispatch(["start", { result }]);
@@ -31,13 +32,13 @@ export class TaskRunner {
 
       EventEmitter.dispatch(["target:start", { result: targetResult }]);
 
-      const compiler = await this.#storeService.load(versionTag, signal);
+      const compiler = await this.#storeService.load(versionTag, cancellationToken);
 
       if (compiler) {
         const testFileRunner = new TestFileRunner(this.resolvedConfig, compiler);
 
         for (const testFile of testFiles) {
-          testFileRunner.run(testFile, signal);
+          testFileRunner.run(testFile, cancellationToken);
         }
       }
 

source/runner/TestFileRunner.ts

@@ -7,6 +7,7 @@ import { EventEmitter } from "#events";
 import { Expect } from "#expect";
 import { ProjectService } from "#project";
 import { FileResult } from "#result";
+import type { CancellationToken } from "#token";
 import { RunMode } from "./enums.js";
 import { TestTreeWorker } from "./TestTreeWorker.js";
 
@@ -22,8 +23,8 @@ export class TestFileRunner {
     this.#projectService = new ProjectService(compiler);
   }
 
-  run(testFile: URL, signal?: AbortSignal): void {
-    if (signal?.aborted === true) {
+  run(testFile: URL, cancellationToken?: CancellationToken): void {
+    if (cancellationToken?.isCancellationRequested === true) {
       return;
     }
 
@@ -36,14 +37,19 @@ export class TestFileRunner {
 
     EventEmitter.dispatch(["file:start", { result: fileResult }]);
 
-    this.#runFile(testFilePath, fileResult, position, signal);
+    this.#runFile(testFilePath, fileResult, position, cancellationToken);
 
     EventEmitter.dispatch(["file:end", { result: fileResult }]);
 
     this.#projectService.closeFile(testFilePath);
   }
 
-  #runFile(testFilePath: string, fileResult: FileResult, position: number | undefined, signal?: AbortSignal) {
+  #runFile(
+    testFilePath: string,
+    fileResult: FileResult,
+    position: number | undefined,
+    cancellationToken?: CancellationToken,
+  ) {
     const languageService = this.#projectService.getLanguageService(testFilePath);
 
     if (!languageService) {
@@ -105,10 +111,10 @@ export class TestFileRunner {
     const expect = new Expect(this.compiler, typeChecker);
 
     const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, expect, {
+      cancellationToken,
       fileResult,
       hasOnly: testTree.hasOnly,
       position,
-      signal,
     });
 
     testTreeWorker.visit(testTree.members, RunMode.Normal, /* parentResult */ undefined);

source/runner/TestTreeWorker.ts

@@ -5,33 +5,34 @@ import { Diagnostic } from "#diagnostic";
 import { EventEmitter } from "#events";
 import type { Expect } from "#expect";
 import { DescribeResult, ExpectResult, type FileResult, TestResult } from "#result";
+import type { CancellationToken } from "#token";
 import { RunMode } from "./enums.js";
 
 interface TestFileWorkerOptions {
+  cancellationToken: CancellationToken | undefined;
   fileResult: FileResult;
   hasOnly: boolean;
   position: number | undefined;
-  signal: AbortSignal | undefined;
 }
 
 export class TestTreeWorker {
+  #cancellationToken: CancellationToken | undefined;
   #expect: Expect;
   #fileResult: FileResult;
   #hasOnly: boolean;
   #position: number | undefined;
-  #signal: AbortSignal | undefined;
 
   constructor(
     readonly resolvedConfig: ResolvedConfig,
     public compiler: typeof ts,
     expect: Expect,
     options: TestFileWorkerOptions,
   ) {
+    this.#cancellationToken = options.cancellationToken;
     this.#expect = expect;
     this.#fileResult = options.fileResult;
     this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
     this.#position = options.position;
-    this.#signal = options.signal;
   }
 
   #resolveRunMode(mode: RunMode, member: TestMember): RunMode {
@@ -69,7 +70,7 @@ export class TestTreeWorker {
     parentResult: DescribeResult | TestResult | undefined,
   ): void {
     for (const member of members) {
-      if (this.#signal?.aborted === true) {
+      if (this.#cancellationToken?.isCancellationRequested === true) {
         break;
       }
 

source/store/Lock.ts

@@ -1,9 +1,10 @@
 import { existsSync, rmSync, writeFileSync } from "node:fs";
 import process from "node:process";
+import type { CancellationToken } from "#token";
 
 export interface IsLockedOptions {
+  cancellationToken?: CancellationToken | undefined;
   onDiagnostic?: (diagnostic: string) => void;
-  signal?: AbortSignal | undefined;
   timeout?: number;
 }
 
@@ -39,7 +40,7 @@ export class Lock {
     const waitStartTime = Date.now();
 
     while (isLocked) {
-      if (options.signal?.aborted === true) {
+      if (options.cancellationToken?.isCancellationRequested === true) {
         break;
       }