tstyche 4.0.0-rc.1 → 4.0.1

package/README.md

@@ -5,7 +5,7 @@
 [![install-size][install-size-badge]][install-size-url]
 [![coverage][coverage-badge]][coverage-url]
 
-The Essential Type Testing Tool.
+Everything You Need for Type Testing.
 
 ---
 
@@ -37,21 +37,29 @@ To organize, debug and plan tests TSTyche has:
 
 ## Assertions
 
-The assertions can be used to write type tests (like in the above example) or mixed in your functional tests:
+The assertions can be used to write type tests (like in the above example) or mixed in your unit tests:
 
 ```ts
 import assert from "node:assert";
 import test from "node:test";
 import * as tstyche from "tstyche";
 
-function secondItem<T>(target: Array<T>): T | undefined {
-  return target[1];
+function toMilliseconds(value: number) {
+  if (typeof value === "number" && !Number.isNaN(value)) {
+    return value * 1000;
+  }
+
+  throw new Error("Not a number");
 }
 
-test("handles numbers", () => {
-  assert.strictEqual(secondItem([1, 2, 3]), 2);
+test("toMilliseconds", () => {
+  const sample = toMilliseconds(10);
+
+  assert.equal(sample, 10_000);
+  tstyche.expect(sample).type.toBe<number>();
 
-  tstyche.expect(secondItem([1, 2, 3])).type.toBe<number | undefined>();
+  // Will pass as a type test and not throw at runtime
+  tstyche.expect(toMilliseconds).type.not.toBeCallableWith("20");
 });
 ```
 

package/build/tstyche.d.ts

@@ -20,152 +20,37 @@ declare class Cli {
     run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
-declare enum OptionBrand {
-    String = "string",
-    Number = "number",
-    Boolean = "boolean",
-    BareTrue = "bareTrue",// a boolean option that does not take a value and when specified is interpreted as 'true'
-    List = "list"
-}
-
-declare class ConfigDiagnosticText {
-    static expected(element: string): string;
-    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
-    static expectsValue(optionName: string): string;
-    static fileDoesNotExist(filePath: string): string;
-    static inspectSupportedVersions(): string;
-    static moduleWasNotFound(specifier: string): string;
-    static rangeIsNotValid(value: string): string;
-    static rangeUsage(): Array<string>;
-    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
-    static seen(element: string): string;
-    static testFileMatchCannotStartWith(segment: string): Array<string>;
-    static unknownOption(optionName: string): string;
-    static usage(optionName: string, optionBrand: OptionBrand): Array<string>;
-    static versionIsNotSupported(value: string): string;
-    static watchCannotBeEnabled(): string;
-}
-
-/**
- * Options passed through the command line.
- */
 interface CommandLineOptions {
-    /**
-     * The path to a TSTyche configuration file.
-     */
     config?: string;
-    /**
-     * Stop running tests after the first failed assertion.
-     */
     failFast?: boolean;
-    /**
-     * Fetch the specified versions of the 'typescript' package and exit.
-     */
     fetch?: boolean;
-    /**
-     * Print the list of command line options with brief descriptions and exit.
-     */
     help?: boolean;
-    /**
-     * Print the list of supported versions of the 'typescript' package and exit.
-     */
     list?: boolean;
-    /**
-     * Print the list of the selected test files and exit.
-     */
     listFiles?: boolean;
-    /**
-     * Only run tests with matching name.
-     */
     only?: string;
-    /**
-     * The list of plugins to use.
-     */
     plugins?: Array<string>;
-    /**
-     * Remove all installed versions of the 'typescript' package and exit.
-     */
     prune?: boolean;
-    /**
-     * The list of reporters to use.
-     */
     reporters?: Array<string>;
-    /**
-     * Print the resolved configuration and exit.
-     */
     showConfig?: boolean;
-    /**
-     * Skip tests with matching name.
-     */
     skip?: string;
-    /**
-     * The list of TypeScript versions to be tested on.
-     */
     target?: Array<string>;
-    /**
-     * The look up strategy to be used to find the TSConfig file.
-     */
     tsconfig?: string;
-    /**
-     * Fetch the 'typescript' package metadata from the registry and exit.
-     */
     update?: boolean;
-    /**
-     * Print the version number and exit.
-     */
     version?: boolean;
-    /**
-     * Watch for changes and rerun related test files.
-     */
     watch?: boolean;
 }
-
-/**
- * Options loaded from the configuration file.
- */
 interface ConfigFileOptions {
-    /**
-     * Enable type error reporting for source files.
-     */
     checkSourceFiles?: boolean;
-    /**
-     * Stop running tests after the first failed assertion.
-     */
     failFast?: boolean;
-    /**
-     * The list of plugins to use.
-     */
     plugins?: Array<string>;
-    /**
-     * Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.
-     */
     rejectAnyType?: boolean;
-    /**
-     * Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.
-     */
     rejectNeverType?: boolean;
-    /**
-     * The list of reporters to use.
-     */
     reporters?: Array<string>;
-    /**
-     * The path to a directory containing files of a test project.
-     */
     rootPath?: string;
-    /**
-     * The list of TypeScript versions to be tested on.
-     */
     target?: Array<string>;
-    /**
-     * The list of glob patterns matching the test files.
-     */
     testFileMatch?: Array<string>;
-    /**
-     * The look up strategy to be used to find the TSConfig file.
-     */
     tsconfig?: string;
 }
-
 interface InlineConfig {
     if?: {
         target?: Array<string>;
@@ -173,13 +58,7 @@ interface InlineConfig {
     template?: boolean;
 }
 interface ResolvedConfig extends Omit<CommandLineOptions, "config" | keyof ConfigFileOptions>, Required<ConfigFileOptions> {
-    /**
-     * The path to a TSTyche configuration file.
-     */
     configFilePath: string;
-    /**
-     * Only run test files with matching path.
-     */
     pathMatch: Array<string>;
 }
 
@@ -202,6 +81,33 @@ declare class Config {
     static resolveConfigFilePath(filePath?: string): string;
 }
 
+declare enum OptionBrand {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    BareTrue = "bareTrue",
+    List = "list"
+}
+
+declare class ConfigDiagnosticText {
+    static expected(element: string): string;
+    static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
+    static expectsValue(optionName: string): string;
+    static fileDoesNotExist(filePath: string): string;
+    static inspectSupportedVersions(): string;
+    static moduleWasNotFound(specifier: string): string;
+    static rangeIsNotValid(value: string): string;
+    static rangeUsage(): Array<string>;
+    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
+    static seen(element: string): string;
+    static testFileMatchCannotStartWith(segment: string): Array<string>;
+    static unexpected(element: string): string;
+    static unknownOption(optionName: string): string;
+    static usage(optionName: string, optionBrand: OptionBrand): Array<string>;
+    static versionIsNotSupported(value: string): string;
+    static watchCannotBeEnabled(): string;
+}
+
 interface TextRange {
     start: number;
     end: number;
@@ -221,6 +127,15 @@ declare class Directive {
     static getInlineConfig(ranges: DirectiveRanges | undefined): Promise<InlineConfig | undefined>;
 }
 
+declare const defaultOptions: Required<ConfigFileOptions>;
+
+declare enum OptionGroup {
+    CommandLine = 2,
+    ConfigFile = 4,
+    InlineConditions = 8,
+    ResolvedConfig = 6
+}
+
 declare enum DiagnosticCategory {
     Error = "error",
     Warning = "warning"
@@ -273,13 +188,6 @@ declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic
 
 type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
 
-declare enum OptionGroup {
-    CommandLine = 2,
-    ConfigFile = 4,
-    InlineConditions = 8,
-    ResolvedConfig = 6
-}
-
 interface BaseOptionDefinition {
     brand: OptionBrand;
     description: string;
@@ -305,8 +213,6 @@ declare class Options {
     static validate(optionName: string, optionValue: string, optionBrand: OptionBrand, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
 }
 
-declare const defaultOptions: Required<ConfigFileOptions>;
-
 declare enum TestTreeNodeBrand {
     Describe = "describe",
     Test = "test",
@@ -385,33 +291,12 @@ declare function argumentIsProvided<T>(argumentNameText: string, node: T, enclos
 declare function argumentOrTypeArgumentIsProvided<T>(argumentNameText: string, typeArgumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
 
 interface EnvironmentOptions {
-    /**
-     * Is `true` if the process is running in continuous integration environment.
-     */
     isCi: boolean;
-    /**
-     * Specifies whether color should be disabled in the output.
-     */
     noColor: boolean;
-    /**
-     * Specifies whether interactive elements should be disabled in the output.
-     */
     noInteractive: boolean;
-    /**
-     * The base URL of the 'npm' registry to use.
-     */
     npmRegistry: string;
-    /**
-     * The directory where to store the 'typescript' packages.
-     */
     storePath: string;
-    /**
-     * The number of seconds to wait before giving up stale operations.
-     */
     timeout: number;
-    /**
-     * The specifier of the TypeScript module.
-     */
     typescriptModule: string | undefined;
 }
 
@@ -751,8 +636,6 @@ interface CodeFrameOptions {
 
 declare function diagnosticText(diagnostic: Diagnostic, codeFrameOptions?: CodeFrameOptions): ScribblerJsx.Element;
 
-declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
-
 declare function fileViewText(lines: Array<ScribblerJsx.Element>, addEmptyFinalLine: boolean): ScribblerJsx.Element;
 
 declare function formattedText(input: string | Array<string> | Record<string, unknown>): ScribblerJsx.Element;
@@ -776,6 +659,8 @@ declare function summaryText({ duration, expectCount, fileCount, targetCount, te
     testCount: ResultCount;
 }): ScribblerJsx.Element;
 
+declare function taskStatusText(status: TaskResultStatus, task: Task): ScribblerJsx.Element;
+
 declare function testNameText(status: "fail" | "pass" | "skip" | "todo", name: string, indent?: number): ScribblerJsx.Element;
 
 declare function usesCompilerText(compilerVersion: string, projectConfigFilePath: string | undefined, options?: {
@@ -798,17 +683,8 @@ interface SelectHookContext {
     resolvedConfig: ResolvedConfig;
 }
 interface Plugin {
-    /**
-     * The name of this plugin.
-     */
     name: string;
-    /**
-     * Is called after configuration is resolved and allows to modify it.
-     */
     config?: (resolvedConfig: ResolvedConfig) => ResolvedConfig | Promise<ResolvedConfig>;
-    /**
-     * Is called after test files are selected and allows to modify the list.
-     */
     select?: (this: SelectHookContext, testFiles: Array<string>) => Array<string | URL> | Promise<Array<string | URL>>;
 }
 

package/build/tstyche.js

@@ -8,73 +8,6 @@ import { createRequire } from 'node:module';
 import vm from 'node:vm';
 import streamConsumers from 'node:stream/consumers';
 
-class ConfigDiagnosticText {
-    static expected(element) {
-        return `Expected ${element}.`;
-    }
-    static expectsListItemType(optionName, optionBrand) {
-        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
-    }
-    static expectsValue(optionName) {
-        return `Option '${optionName}' expects a value.`;
-    }
-    static fileDoesNotExist(filePath) {
-        return `The specified path '${filePath}' does not exist.`;
-    }
-    static inspectSupportedVersions() {
-        return "Use the '--list' command line option to inspect the list of supported versions.";
-    }
-    static moduleWasNotFound(specifier) {
-        return `The specified module '${specifier}' was not found.`;
-    }
-    static rangeIsNotValid(value) {
-        return `The specified range '${value}' is not valid.`;
-    }
-    static rangeUsage() {
-        return [
-            "A range must be specified using an operator and a minor version.",
-            "To set an upper bound, the intersection of two ranges can be used.",
-            "Examples: '>=5.5', '>=5.0 <5.3'.",
-        ];
-    }
-    static requiresValueType(optionName, optionBrand) {
-        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
-    }
-    static seen(element) {
-        return `The ${element} was seen here.`;
-    }
-    static testFileMatchCannotStartWith(segment) {
-        return [
-            `A test file match pattern cannot start with '${segment}'.`,
-            "The test files are only collected within the 'rootPath' directory.",
-        ];
-    }
-    static unknownOption(optionName) {
-        return `Unknown option '${optionName}'.`;
-    }
-    static usage(optionName, optionBrand) {
-        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
-            case "target": {
-                const text = [];
-                if (optionName.startsWith("--")) {
-                    text.push("Value for the '--target' option must be a string or a comma separated list.", "Examples: '--target 5.2', '--target next', '--target '>=5.0 <5.3, 5.4.2, >=5.5''.");
-                }
-                return text;
-            }
-        }
-        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
-    }
-    static versionIsNotSupported(value) {
-        if (value === "current") {
-            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
-        }
-        return `TypeScript version '${value}' is not supported.`;
-    }
-    static watchCannotBeEnabled() {
-        return "Watch mode cannot be enabled in continuous integration environment.";
-    }
-}
-
 var DiagnosticCategory;
 (function (DiagnosticCategory) {
     DiagnosticCategory["Error"] = "error";
@@ -279,6 +212,76 @@ class Path {
     }
 }
 
+class ConfigDiagnosticText {
+    static expected(element) {
+        return `Expected ${element}.`;
+    }
+    static expectsListItemType(optionName, optionBrand) {
+        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
+    }
+    static expectsValue(optionName) {
+        return `Option '${optionName}' expects a value.`;
+    }
+    static fileDoesNotExist(filePath) {
+        return `The specified path '${filePath}' does not exist.`;
+    }
+    static inspectSupportedVersions() {
+        return "Use the '--list' command line option to inspect the list of supported versions.";
+    }
+    static moduleWasNotFound(specifier) {
+        return `The specified module '${specifier}' was not found.`;
+    }
+    static rangeIsNotValid(value) {
+        return `The specified range '${value}' is not valid.`;
+    }
+    static rangeUsage() {
+        return [
+            "A range must be specified using an operator and a minor version.",
+            "To set an upper bound, the intersection of two ranges can be used.",
+            "Examples: '>=5.5', '>=5.0 <5.3'.",
+        ];
+    }
+    static requiresValueType(optionName, optionBrand) {
+        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
+    }
+    static seen(element) {
+        return `The ${element} was seen here.`;
+    }
+    static testFileMatchCannotStartWith(segment) {
+        return [
+            `A test file match pattern cannot start with '${segment}'.`,
+            "The test files are only collected within the 'rootPath' directory.",
+        ];
+    }
+    static unexpected(element) {
+        return `Unexpected ${element}.`;
+    }
+    static unknownOption(optionName) {
+        return `Unknown option '${optionName}'.`;
+    }
+    static usage(optionName, optionBrand) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "target": {
+                const text = [];
+                if (optionName.startsWith("--")) {
+                    text.push("Value for the '--target' option must be a string or a comma separated list.", "Examples: '--target 5.2', '--target next', '--target '>=5.0 <5.3, 5.4.2, >=5.5''.");
+                }
+                return text;
+            }
+        }
+        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
+    }
+    static versionIsNotSupported(value) {
+        if (value === "current") {
+            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
+        }
+        return `TypeScript version '${value}' is not supported.`;
+    }
+    static watchCannotBeEnabled() {
+        return "Watch mode cannot be enabled in continuous integration environment.";
+    }
+}
+
 var OptionBrand;
 (function (OptionBrand) {
     OptionBrand["String"] = "string";
@@ -510,7 +513,7 @@ class LockService {
         }
         return isLocked;
     }
-    async #sleep(delay) {
+    #sleep(delay) {
         return new Promise((resolve) => setTimeout(resolve, delay));
     }
 }
@@ -1375,6 +1378,13 @@ class ConfigParser {
                 related: [Diagnostic.error(relatedText, leftBraceToken.origin)],
             });
             this.#onDiagnostics(diagnostic);
+            return;
+        }
+        const unexpectedToken = this.#jsonScanner.readToken(/\S/);
+        if (unexpectedToken.text != null) {
+            const text = ConfigDiagnosticText.unexpected("token");
+            const diagnostic = Diagnostic.error(text, unexpectedToken.origin);
+            this.#onDiagnostics(diagnostic);
         }
     }
     async parse() {
@@ -1382,6 +1392,19 @@ class ConfigParser {
     }
 }
 
+const defaultOptions = {
+    checkSourceFiles: true,
+    failFast: false,
+    plugins: [],
+    rejectAnyType: true,
+    rejectNeverType: true,
+    reporters: ["list", "summary"],
+    rootPath: Path.resolve("./"),
+    target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
+    testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
+    tsconfig: "findup",
+};
+
 class JsonNode {
     origin;
     text;
@@ -1474,9 +1497,10 @@ class JsonScanner {
     readToken(token) {
         this.#skipTrivia();
         this.#previousPosition = this.#position;
-        if (this.#peekCharacter() === token) {
+        const character = this.#peekCharacter();
+        if (typeof token === "string" ? token === character : token.test(character)) {
             this.#position++;
-            return new JsonNode(token, this.#getOrigin());
+            return new JsonNode(character, this.#getOrigin());
         }
         return new JsonNode(undefined, this.#getOrigin());
     }
@@ -1514,19 +1538,6 @@ class JsonScanner {
     }
 }
 
-const defaultOptions = {
-    checkSourceFiles: true,
-    failFast: false,
-    plugins: [],
-    rejectAnyType: true,
-    rejectNeverType: true,
-    reporters: ["list", "summary"],
-    rootPath: Path.resolve("./"),
-    target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
-    testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
-    tsconfig: "findup",
-};
-
 class Config {
     static #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
@@ -1578,20 +1589,19 @@ class Config {
 }
 
 class DirectiveDiagnosticText {
-    static doesNotTakeArgument(directiveName) {
-        return `Directive '${directiveName}' does not take an argument.`;
+    static doesNotTakeArgument() {
+        return "Directive does not take an argument.";
     }
     static isNotSupported(directive) {
         return `The '${directive}' directive is not supported.`;
     }
-    static requiresArgument(directiveName) {
-        return `Directive '${directiveName}' requires an argument.`;
+    static requiresArgument() {
+        return "Directive requires an argument.";
     }
 }
 
 class Directive {
-    static #commentSeparatorRegex = /--+/;
-    static #directiveRegex = /^(\/\/\s*@tstyche)(\s*|-)?(\S*)?(\s*)?(.*)?/i;
+    static #directiveRegex = /^(\/\/ *@tstyche)( *|-)?(\S*)?( *)?(.*)?/i;
     static getDirectiveRanges(compiler, sourceFile, position = 0) {
         const comments = compiler.getLeadingCommentRanges(sourceFile.text, position);
         if (!comments || comments.length === 0) {
@@ -1620,28 +1630,28 @@ class Directive {
         return inlineConfig;
     }
     static #getRange(sourceFile, comment) {
-        const [text] = sourceFile.text.substring(comment.pos, comment.end).split(Directive.#commentSeparatorRegex);
-        const found = text?.match(Directive.#directiveRegex);
-        const namespaceText = found?.[1];
+        const [text] = sourceFile.text.substring(comment.pos, comment.end).split(/--+/);
+        const match = text?.match(Directive.#directiveRegex);
+        const namespaceText = match?.[1];
         if (!namespaceText) {
             return;
         }
-        const ranges = {
+        const range = {
             namespace: { start: comment.pos, end: comment.pos + namespaceText.length, text: namespaceText },
         };
-        const directiveSeparatorText = found?.[2];
-        const directiveText = found?.[3];
-        if (directiveText != null && directiveText.length > 0) {
-            const start = ranges.namespace.end + (directiveSeparatorText?.length ?? 0);
-            ranges.directive = { start, end: start + directiveText.length, text: directiveText };
-        }
-        const argumentSeparatorText = found?.[4];
-        const argumentText = found?.[5]?.trimEnd();
-        if (ranges.directive != null && argumentText != null && argumentText.length > 0) {
-            const start = ranges.directive.end + (argumentSeparatorText?.length ?? 0);
-            ranges.argument = { start, end: start + argumentText.length, text: argumentText };
+        const directiveSeparatorText = match?.[2];
+        const directiveText = match?.[3];
+        if (typeof directiveText === "string" && typeof directiveSeparatorText === "string") {
+            const start = range.namespace.end + directiveSeparatorText.length;
+            range.directive = { start, end: start + directiveText.length, text: directiveText };
+            const argumentSeparatorText = match?.[4];
+            const argumentText = match?.[5]?.trimEnd();
+            if (typeof argumentSeparatorText === "string" && typeof argumentText === "string") {
+                const start = range.directive.end + argumentSeparatorText.length;
+                range.argument = { start, end: start + argumentText.length, text: argumentText };
+            }
         }
-        return ranges;
+        return range;
     }
     static #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["directive:error", { diagnostics: [diagnostic] }]);
@@ -1651,8 +1661,8 @@ class Directive {
             case "if":
                 {
                     if (!ranges.argument?.text) {
-                        const text = DirectiveDiagnosticText.requiresArgument(ranges.directive.text);
-                        const origin = new DiagnosticOrigin(ranges.directive.start, ranges.directive.end, sourceFile);
+                        const text = DirectiveDiagnosticText.requiresArgument();
+                        const origin = new DiagnosticOrigin(ranges.namespace.start, ranges.directive.end, sourceFile);
                         Directive.#onDiagnostics(Diagnostic.error(text, origin));
                         return;
                     }
@@ -1662,8 +1672,8 @@ class Directive {
                 return;
             case "template":
                 if (ranges.argument?.text != null) {
-                    const text = DirectiveDiagnosticText.doesNotTakeArgument(ranges.directive.text);
-                    const origin = new DiagnosticOrigin(ranges.directive.start, ranges.directive.end, sourceFile);
+                    const text = DirectiveDiagnosticText.doesNotTakeArgument();
+                    const origin = new DiagnosticOrigin(ranges.argument.start, ranges.argument.end, sourceFile);
                     Directive.#onDiagnostics(Diagnostic.error(text, origin));
                 }
                 inlineConfig.template = true;
@@ -2204,33 +2214,6 @@ function diagnosticText(diagnostic, codeFrameOptions = {}) {
     return (jsx(Text, { children: [prefix, jsx(DiagnosticText, { codeFrameOptions: codeFrameOptions, diagnostic: diagnostic })] }));
 }
 
-function FileNameText({ filePath }) {
-    const relativePath = Path.relative("", filePath);
-    const lastPathSeparator = relativePath.lastIndexOf("/");
-    const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
-    const fileNameText = relativePath.slice(lastPathSeparator + 1);
-    return (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: directoryNameText }), fileNameText] }));
-}
-function taskStatusText(status, task) {
-    let statusColor;
-    let statusText;
-    switch (status) {
-        case ResultStatus.Runs:
-            statusColor = Color.Yellow;
-            statusText = "runs";
-            break;
-        case ResultStatus.Passed:
-            statusColor = Color.Green;
-            statusText = "pass";
-            break;
-        case ResultStatus.Failed:
-            statusColor = Color.Red;
-            statusText = "fail";
-            break;
-    }
-    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: task.filePath })] }));
-}
-
 function fileViewText(lines, addEmptyFinalLine) {
     return (jsx(Text, { children: [[...lines], addEmptyFinalLine ? jsx(Line, {}) : undefined] }));
 }
@@ -2350,6 +2333,33 @@ function summaryText({ duration, expectCount, fileCount, targetCount, testCount,
     return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) })] }));
 }
 
+function FileNameText({ filePath }) {
+    const relativePath = Path.relative("", filePath);
+    const lastPathSeparator = relativePath.lastIndexOf("/");
+    const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
+    const fileNameText = relativePath.slice(lastPathSeparator + 1);
+    return (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: directoryNameText }), fileNameText] }));
+}
+function taskStatusText(status, task) {
+    let statusColor;
+    let statusText;
+    switch (status) {
+        case ResultStatus.Runs:
+            statusColor = Color.Yellow;
+            statusText = "runs";
+            break;
+        case ResultStatus.Passed:
+            statusColor = Color.Green;
+            statusText = "pass";
+            break;
+        case ResultStatus.Failed:
+            statusColor = Color.Red;
+            statusText = "fail";
+            break;
+    }
+    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: task.filePath })] }));
+}
+
 function StatusText({ status }) {
     switch (status) {
         case "fail":
@@ -2635,6 +2645,14 @@ class Task {
     }
 }
 
+var CancellationReason;
+(function (CancellationReason) {
+    CancellationReason["ConfigChange"] = "configChange";
+    CancellationReason["ConfigError"] = "configError";
+    CancellationReason["FailFast"] = "failFast";
+    CancellationReason["WatchClose"] = "watchClose";
+})(CancellationReason || (CancellationReason = {}));
+
 class CancellationToken {
     #isCancelled = false;
     #reason;
@@ -2658,14 +2676,6 @@ class CancellationToken {
     }
 }
 
-var CancellationReason;
-(function (CancellationReason) {
-    CancellationReason["ConfigChange"] = "configChange";
-    CancellationReason["ConfigError"] = "configError";
-    CancellationReason["FailFast"] = "failFast";
-    CancellationReason["WatchClose"] = "watchClose";
-})(CancellationReason || (CancellationReason = {}));
-
 class Watcher {
     #onChanged;
     #onRemoved;
@@ -3037,7 +3047,8 @@ class AssertionNode extends TestTreeNode {
             this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
         }
         for (const diagnostic of parent.diagnostics) {
-            if (diagnosticBelongsToNode(diagnostic, this.source)) {
+            if (diagnosticBelongsToNode(diagnostic, this.source) ||
+                (this.target != null && diagnosticBelongsToNode(diagnostic, this.target))) {
                 this.diagnostics.add(diagnostic);
                 parent.diagnostics.delete(diagnostic);
             }
@@ -3629,6 +3640,7 @@ var RunMode;
     RunMode[RunMode["Only"] = 2] = "Only";
     RunMode[RunMode["Skip"] = 4] = "Skip";
     RunMode[RunMode["Todo"] = 8] = "Todo";
+    RunMode[RunMode["Void"] = 16] = "Void";
 })(RunMode || (RunMode = {}));
 
 class EnsureDiagnosticText {
@@ -4674,7 +4686,7 @@ class TestTreeWalker {
         const directiveRanges = node.getDirectiveRanges(this.#compiler);
         const inlineConfig = await Directive.getInlineConfig(directiveRanges);
         if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
-            mode |= RunMode.Skip;
+            mode |= RunMode.Void;
         }
         if (node.flags & TestTreeNodeFlags.Fail) {
             mode |= RunMode.Fail;
@@ -4719,9 +4731,12 @@ class TestTreeWalker {
     }
     async #visitAssertion(assertion, runMode, parentResult) {
         await this.visit(assertion.children, runMode, parentResult);
+        runMode = await this.#resolveRunMode(runMode, assertion);
+        if (runMode & RunMode.Void) {
+            return;
+        }
         const expectResult = new ExpectResult(assertion, parentResult);
         EventEmitter.dispatch(["expect:start", { result: expectResult }]);
-        runMode = await this.#resolveRunMode(runMode, assertion);
         if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
             EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
             return;
@@ -4758,9 +4773,12 @@ class TestTreeWalker {
         }
     }
     async #visitDescribe(describe, runMode, parentResult) {
+        runMode = await this.#resolveRunMode(runMode, describe);
+        if (runMode & RunMode.Void) {
+            return;
+        }
         const describeResult = new DescribeResult(describe, parentResult);
         EventEmitter.dispatch(["describe:start", { result: describeResult }]);
-        runMode = await this.#resolveRunMode(runMode, describe);
         if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only)) || runMode & RunMode.Todo) &&
             describe.diagnostics.size > 0) {
             this.#onTaskDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
@@ -4771,9 +4789,12 @@ class TestTreeWalker {
         EventEmitter.dispatch(["describe:end", { result: describeResult }]);
     }
     async #visitTest(test, runMode, parentResult) {
+        runMode = await this.#resolveRunMode(runMode, test);
+        if (runMode & RunMode.Void) {
+            return;
+        }
         const testResult = new TestResult(test, parentResult);
         EventEmitter.dispatch(["test:start", { result: testResult }]);
-        runMode = await this.#resolveRunMode(runMode, test);
         if (runMode & RunMode.Todo) {
             EventEmitter.dispatch(["test:todo", { result: testResult }]);
             return;
@@ -4894,7 +4915,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-rc.1";
+    static version = "4.0.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tstyche",
-  "version": "4.0.0-rc.1",
-  "description": "The Essential Type Testing Tool.",
+  "version": "4.0.1",
+  "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",
     "types",