tstyche 7.0.0-beta.2 → 7.0.0-beta.4

package/README.md

@@ -40,28 +40,36 @@ To group and organize tests, TSTyche has:
 The `expect` style assertions can check either the inferred type of an expression (as in the example above) or a type directly:
 
 ```ts
-import { expect } from "tstyche";
+import { type _, expect } from "tstyche";
 
 type AsyncProps<T> = {
   [K in keyof T]+?: T[K] | Promise<T[K]>;
 };
 
-type WithLoading<T> = T & { loading: boolean };
+type WithLoading<T extends object> = T & { loading: boolean };
 
 expect<WithLoading<AsyncProps<{ query: string }>>>().type.toBe<{
   query?: string | Promise<string>;
   loading: boolean;
 }>();
+
+expect<WithLoading<_>>().type.not.toBeInstantiableWith<[string]>();
 ```
 
-Here is the list of all matchers:
+Relation matchers:
+
+- `.toBe()` checks if a type is the same as the given type,
+- `.toBeAssignableFrom()` checks if a type is assignable from the given type,
+- `.toBeAssignableTo()` checks if a type is assignable to the given type.
+
+Ability matchers:
 
-- `.toBe()`, `.toBeAssignableFrom()`, `.toBeAssignableTo()` compare types or type of expressions,
-- `.toAcceptProps()` checks the type of JSX component props,
-- `.toBeApplicable` ensures that the decorator function can be applied,
-- `.toBeCallableWith()` checks whether a function is callable with the given arguments,
-- `.toBeConstructableWith()` checks whether a class is constructable with the given arguments,
-- `.toHaveProperty()` looks up keys on an object type.
+- `.toAcceptProps()` checks if a JSX component accepts the given props,
+- `.toBeApplicable` checks if a decorator is applicable to the given class or class member,
+- `.toBeCallableWith()` checks if a function is callable with the given arguments,
+- `.toBeConstructableWith()` checks if a class is constructable with the given arguments,
+- `.toBeInstantiableWith()` checks if a generic is instantiable with the given type arguments,
+- `.toHaveProperty()` checks if a type has the given property.
 
 ## Runner
 

package/dist/api.d.ts

@@ -15,13 +15,9 @@ declare class CancellationToken {
     reset(): void;
 }
 
-interface CliOptions {
-    noErrorExitCode?: boolean;
-}
 declare class Cli {
     #private;
-    constructor(options?: CliOptions);
-    run(commandLine: ReadonlyArray<string>, cancellationToken?: CancellationToken): Promise<void>;
+    run(commandLine: ReadonlyArray<string>, cancellationToken?: CancellationToken): Promise<number>;
 }
 
 declare enum DiagnosticCategory {
@@ -755,4 +751,4 @@ declare class Version {
 }
 
 export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, DotReporter, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectConfigKind, ProjectResult, Result, ResultStatus, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, Store, StreamController, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, dotText, environmentOptions, fileStatusText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesText, waitingForFileChangesText, watchUsageText };
-export type { AssertionCounts, AssertionResultStatus, CliOptions, CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, EnvironmentOptions, Event, EventHandler, FileCounts, FileResultStatus, InlineConfig, ItemDefinition, OptionDefinition, ProjectConfig, Reporter, ReporterEvent, ResolvedConfig, ResultCounts, ResultTiming, ScribblerOptions, SuppressedCounts, SuppressedResultStatus, TargetCounts, TargetResultStatus, TestCounts, TestResultStatus, TextRange, WriteStream };
+export type { AssertionCounts, AssertionResultStatus, CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, EnvironmentOptions, Event, EventHandler, FileCounts, FileResultStatus, InlineConfig, ItemDefinition, OptionDefinition, ProjectConfig, Reporter, ReporterEvent, ResolvedConfig, ResultCounts, ResultTiming, ScribblerOptions, SuppressedCounts, SuppressedResultStatus, TargetCounts, TargetResultStatus, TestCounts, TestResultStatus, TextRange, WriteStream };

package/dist/api.js

@@ -56,25 +56,24 @@ class JsonNode {
         this.text = text;
     }
     getValue(options) {
-        if (this.text == null) {
-            return undefined;
-        }
-        if (/^['"]/.test(this.text)) {
-            return this.text.slice(1, -1).replaceAll("\\", "");
-        }
-        if (options?.expectsIdentifier) {
-            return this.text;
-        }
-        if (this.text === "true") {
-            return true;
-        }
-        if (this.text === "false") {
-            return false;
-        }
-        if (/^\d/.test(this.text)) {
-            return Number.parseFloat(this.text);
+        if (this.text != null) {
+            if (/^['"]/.test(this.text)) {
+                return this.text.slice(1, -1).replaceAll("\\", "");
+            }
+            if (options?.expectsIdentifier) {
+                return this.text;
+            }
+            if (this.text === "true") {
+                return true;
+            }
+            if (this.text === "false") {
+                return false;
+            }
+            if (/^\d/.test(this.text)) {
+                return Number.parseFloat(this.text);
+            }
         }
-        return undefined;
+        return;
     }
 }
 
@@ -730,7 +729,9 @@ class ManifestService {
         const versions = [];
         const packageMetadata = (await response.json());
         for (const [tag, meta] of Object.entries(packageMetadata.versions)) {
-            if (!tag.includes("-") && Version.isSatisfiedWith(tag, "5.4.2")) {
+            if (!tag.includes("-") &&
+                Version.isSatisfiedWith(tag, "5.4") &&
+                !Version.isSatisfiedWith(tag, "7.0")) {
                 versions.push(tag);
                 packages[tag] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
             }
@@ -752,6 +753,7 @@ class ManifestService {
                 }
             }
         }
+        resolutions["latest"] = versions.findLast((version) => version.startsWith("6"));
         return new Manifest({ minorVersions, npmRegistry: this.#npmRegistry, packages, resolutions, versions });
     }
     async open(options) {
@@ -1795,22 +1797,23 @@ class CancellationHandler {
 }
 
 class ExitCodeHandler {
+    #exitCode = 0;
+    getExitCode() {
+        return this.#exitCode;
+    }
     on([event, payload]) {
         if (event === "run:start") {
-            this.resetCode();
+            this.#exitCode = 0;
             return;
         }
         if ("diagnostics" in payload) {
             if (payload.diagnostics.some((diagnostic) => diagnostic.category === "error")) {
-                this.#setCode(1);
+                this.#exitCode = 1;
             }
         }
     }
-    resetCode() {
-        this.#setCode(0);
-    }
-    #setCode(exitCode) {
-        process.exitCode = exitCode;
+    reset() {
+        this.#exitCode = 0;
     }
 }
 
@@ -3450,6 +3453,51 @@ class AbilityLayer {
                 }
                 break;
             }
+            case "toBeInstantiableWith": {
+                this.#nodes.push(expect);
+                const sourceNode = expect.source[0];
+                const targetNode = expect.target?.[0];
+                if (!sourceNode) {
+                    return;
+                }
+                if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+                    this.#editor.eraseTrailingComma(expect.source);
+                    this.#editor.replaceRanges([
+                        [
+                            expectStart,
+                            expectExpressionEnd,
+                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "",
+                        ],
+                        [expectEnd, matcherNodeEnd],
+                    ]);
+                    if (this.#compiler.isExpressionWithTypeArguments(sourceNode)) {
+                        this.#editor.replaceRanges([[sourceNode.expression.getEnd(), sourceNode.getEnd()]]);
+                    }
+                }
+                else {
+                    const sourceText = this.#compiler.isTypeReferenceNode(sourceNode)
+                        ? sourceNode.typeName.getText()
+                        : sourceNode.getText();
+                    this.#editor.replaceRanges([
+                        [
+                            expectStart,
+                            matcherNodeEnd,
+                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
+                                ? `;undefined as any as ${sourceText}`
+                                : `undefined as any as ${sourceText}`,
+                        ],
+                    ]);
+                }
+                if (targetNode != null) {
+                    const targetText = targetNode.getText().slice(1, -1);
+                    if (targetText.trim().length > 1) {
+                        this.#editor.replaceRanges([
+                            [targetNode.getFullStart(), targetNode.getEnd(), `<${targetText}>`.padStart(targetNode.getFullWidth())],
+                        ]);
+                    }
+                }
+                break;
+            }
             case "toHaveProperty": {
                 this.#nodes.push(expect);
                 const sourceNode = expect.source[0];
@@ -4327,10 +4375,13 @@ class EnsureDiagnosticText {
     static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
         return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
     }
+    static typeArgumentMustBeProvided(typeArgumentNameText) {
+        return `Type argument for '${typeArgumentNameText}' must be provided.`;
+    }
 }
 
-function argumentIsProvided(argumentNameText, node, enclosingNode, onDiagnostics) {
-    if (!node) {
+function argumentIsProvided(compiler, argumentNameText, node, enclosingNode, onDiagnostics) {
+    if (!node || !nodeBelongsToArgumentList(compiler, node)) {
         const text = EnsureDiagnosticText.argumentMustBeProvided(argumentNameText);
         const origin = DiagnosticOrigin.fromNode(enclosingNode);
         onDiagnostics([Diagnostic.error(text, origin)]);
@@ -4349,6 +4400,16 @@ function argumentOrTypeArgumentIsProvided(argumentNameText, typeArgumentNameText
     return true;
 }
 
+function typeArgumentIsProvided(compiler, typeArgumentNameText, node, enclosingNode, onDiagnostics) {
+    if (!node || nodeBelongsToArgumentList(compiler, node)) {
+        const text = EnsureDiagnosticText.typeArgumentMustBeProvided(typeArgumentNameText);
+        const origin = DiagnosticOrigin.fromNode(enclosingNode);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+        return false;
+    }
+    return true;
+}
+
 class ExpectDiagnosticText {
     static argumentMustBe(argumentNameText, expectedText) {
         return `An argument for '${argumentNameText}' must be ${expectedText}.`;
@@ -4368,6 +4429,12 @@ class ExpectDiagnosticText {
     static isNotConstructable(isExpression, targetText) {
         return `${isExpression ? "Expression" : "Type"} is not constructable ${targetText}.`;
     }
+    static isInstantiable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is instantiable ${targetText}.`;
+    }
+    static isNotInstantiable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is not instantiable ${targetText}.`;
+    }
     static acceptsProps(isExpression) {
         return `${isExpression ? "Component" : "Component type"} accepts props of the given type.`;
     }
@@ -4453,12 +4520,12 @@ class MatchWorker {
         this.typeChecker = program.getTypeChecker();
         this.assertionNode = assertionNode;
     }
+    checkIsAssignableFrom(sourceNode, targetNode) {
+        return this.#checkIsRelatedTo(targetNode, sourceNode);
+    }
     checkIsAssignableTo(sourceNode, targetNode) {
         return this.#checkIsRelatedTo(sourceNode, targetNode);
     }
-    checkIsAssignableWith(sourceNode, targetNode) {
-        return this.#checkIsRelatedTo(targetNode, sourceNode);
-    }
     #checkIsRelatedTo(sourceNode, targetNode) {
         const sourceType = this.getType(sourceNode);
         const targetType = this.getType(targetNode);
@@ -5314,7 +5381,7 @@ class ToBeAssignableFrom extends RelationMatcherBase {
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
-            isMatch: matchWorker.checkIsAssignableWith(sourceNode, targetNode),
+            isMatch: matchWorker.checkIsAssignableFrom(sourceNode, targetNode),
         };
     }
 }
@@ -5335,7 +5402,7 @@ class AbilityMatcherBase {
     constructor(compiler) {
         this.compiler = compiler;
     }
-    #resolveTargetText(nodes) {
+    getArgumentCountText(nodes) {
         if (nodes.length === 0) {
             return "without arguments";
         }
@@ -5344,15 +5411,21 @@ class AbilityMatcherBase {
         }
         return `with the given argument${nodes.length === 1 ? "" : "s"}`;
     }
-    explain(matchWorker, sourceNode, targetNodes) {
+    getTypeArgumentCountText(targetNode) {
+        if (targetNode.elements.length === 0) {
+            return "without type arguments";
+        }
+        return `with the given type argument${targetNode.elements.length === 1 ? "" : "s"}`;
+    }
+    explain(matchWorker, sourceNode, targetNode, getArgumentCountText) {
         const isExpression = nodeBelongsToArgumentList(this.compiler, sourceNode);
-        const targetText = this.#resolveTargetText(targetNodes);
+        const argumentCountText = getArgumentCountText();
         const diagnostics = [];
         if (matchWorker.assertionNode.abilityDiagnostics.size > 0) {
             for (const diagnostic of matchWorker.assertionNode.abilityDiagnostics) {
-                const text = [this.explainNotText(isExpression, targetText), getDiagnosticMessageText(diagnostic)];
+                const text = [this.explainNotText(isExpression, argumentCountText), getDiagnosticMessageText(diagnostic)];
                 let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNode)) {
                     origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertionNode);
                 }
                 else {
@@ -5367,7 +5440,7 @@ class AbilityMatcherBase {
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
-            diagnostics.push(Diagnostic.error(this.explainText(isExpression, targetText), origin));
+            diagnostics.push(Diagnostic.error(this.explainText(isExpression, argumentCountText), origin));
         }
         return diagnostics;
     }
@@ -5394,7 +5467,7 @@ class ToBeCallableWith extends AbilityMatcherBase {
             return;
         }
         return {
-            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes, () => this.getArgumentCountText(targetNodes)),
             isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
@@ -5421,7 +5494,38 @@ class ToBeConstructableWith extends AbilityMatcherBase {
             return;
         }
         return {
-            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes, () => this.getArgumentCountText(targetNodes)),
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
+        };
+    }
+}
+
+class ToBeInstantiableWith extends AbilityMatcherBase {
+    explainText = ExpectDiagnosticText.isInstantiable;
+    explainNotText = ExpectDiagnosticText.isNotInstantiable;
+    match(matchWorker, sourceNode, targetNode, onDiagnostics) {
+        if (!(this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isTypeReferenceNode(sourceNode) ||
+            this.compiler.isExpressionWithTypeArguments(sourceNode))) {
+            let text;
+            if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
+                text = ExpectDiagnosticText.argumentMustBe("source", "an instantiable expression");
+            }
+            else {
+                text = ExpectDiagnosticText.typeArgumentMustBe("Source", "an instantiable type");
+            }
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        if (!this.compiler.isTupleTypeNode(targetNode)) {
+            const text = ExpectDiagnosticText.typeArgumentMustBe("Target", "a tuple type");
+            const origin = DiagnosticOrigin.fromNode(targetNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.explain(matchWorker, sourceNode, targetNode, () => this.getTypeArgumentCountText(targetNode)),
             isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
@@ -5572,6 +5676,7 @@ class ExpectService {
     toBeAssignableTo;
     toBeCallableWith;
     toBeConstructableWith;
+    toBeInstantiableWith;
     toHaveProperty;
     toRaiseError;
     constructor(compiler, program, reject) {
@@ -5585,6 +5690,7 @@ class ExpectService {
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeCallableWith = new ToBeCallableWith(compiler);
         this.toBeConstructableWith = new ToBeConstructableWith(compiler);
+        this.toBeInstantiableWith = new ToBeInstantiableWith(compiler);
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toRaiseError = new ToRaiseError(compiler);
     }
@@ -5594,7 +5700,7 @@ class ExpectService {
             return;
         }
         const matchWorker = new MatchWorker(this.#compiler, this.#program, assertionNode);
-        if (!(matcherNameText === "toRaiseError" && !assertionNode.isNot) &&
+        if (!(matcherNameText === "toBeInstantiableWith" || (matcherNameText === "toRaiseError" && !assertionNode.isNot)) &&
             this.#reject.argumentType([
                 ["source", assertionNode.source[0]],
                 ["target", assertionNode.target?.[0]],
@@ -5616,8 +5722,14 @@ class ExpectService {
             case "toBeConstructableWith":
             case "toRaiseError":
                 return this[matcherNameText].match(matchWorker, assertionNode.source[0], assertionNode.target, onDiagnostics);
+            case "toBeInstantiableWith": {
+                if (!typeArgumentIsProvided(this.#compiler, "Target", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
+                    return;
+                }
+                return this.toBeInstantiableWith.match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
+            }
             case "toHaveProperty":
-                if (!argumentIsProvided("key", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
+                if (!argumentIsProvided(this.#compiler, "key", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
@@ -5701,14 +5813,16 @@ class WhenDiagnosticText {
 }
 
 class WhenService {
+    #compiler;
     #onDiagnostics;
     #reject;
-    constructor(reject, onDiagnostics) {
+    constructor(compiler, reject, onDiagnostics) {
+        this.#compiler = compiler;
         this.#reject = reject;
         this.#onDiagnostics = onDiagnostics;
     }
     action(when) {
-        if (!argumentIsProvided("target", when.target[0], when.node.expression, this.#onDiagnostics) ||
+        if (!argumentIsProvided(this.#compiler, "target", when.target[0], when.node.expression, this.#onDiagnostics) ||
             this.#reject.argumentType([["target", when.target[0]]], this.#onDiagnostics)) {
             return;
         }
@@ -5825,7 +5939,7 @@ class TestTreeWalker {
         this.#position = options.position;
         const reject = new Reject(compiler, program, resolvedConfig);
         this.#expectService = new ExpectService(compiler, program, reject);
-        this.#whenService = new WhenService(reject, onFileDiagnostics);
+        this.#whenService = new WhenService(compiler, reject, onFileDiagnostics);
     }
     async #resolveRunMode(flags, node) {
         const ifDirective = Directive.getDirectiveRange(this.#compiler, node, "if");
@@ -6065,7 +6179,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "7.0.0-beta.2";
+    static version = "7.0.0-beta.4";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -6164,15 +6278,20 @@ class CliDiagnosticText {
 class Cli {
     #deferredDiagnostics;
     #eventEmitter = new EventEmitter();
-    #noErrorExitCode;
-    constructor(options) {
-        this.#noErrorExitCode = options?.noErrorExitCode ?? false;
-    }
     async run(commandLine, cancellationToken = new CancellationToken()) {
+        const exitCodeHandler = new ExitCodeHandler();
+        this.#eventEmitter.addHandler(exitCodeHandler);
+        await this.#run(commandLine, exitCodeHandler, cancellationToken);
+        if (this.#deferredDiagnostics != null) {
+            OutputService.writeBlankLine();
+            OutputService.writeWarning(diagnosticText(this.#deferredDiagnostics));
+        }
+        this.#eventEmitter.removeHandlers();
+        return exitCodeHandler.getExitCode();
+    }
+    async #run(commandLine, exitCodeHandler, cancellationToken) {
         const cancellationHandler = new CancellationHandler(cancellationToken, "configError");
         this.#eventEmitter.addHandler(cancellationHandler);
-        const exitCodeHandler = new ExitCodeHandler();
-        !this.#noErrorExitCode && this.#eventEmitter.addHandler(exitCodeHandler);
         const setupReporter = new SetupReporter();
         this.#eventEmitter.addReporter(setupReporter);
         if (commandLine.includes("--help")) {
@@ -6205,7 +6324,7 @@ class Cli {
         }
         if (!commandLineOptions.config) {
             const oldConfigFilePath = Path.resolve(Config.resolveRootPath(commandLineOptions.root), "./tstyche.config.json");
-            if (existsSync(oldConfigFilePath) && !environmentOptions.isCi) {
+            if (existsSync(oldConfigFilePath)) {
                 const newConfigFilePath = Path.resolve(Config.resolveConfigFilePath(undefined, commandLineOptions.root));
                 await fs.rename(oldConfigFilePath, newConfigFilePath);
                 this.#deferredDiagnostics = Diagnostic.warning(CliDiagnosticText.configLocationChanged(oldConfigFilePath, newConfigFilePath));
@@ -6214,7 +6333,7 @@ class Cli {
         do {
             if (cancellationToken.getReason() === "configChange") {
                 cancellationToken.reset();
-                exitCodeHandler.resetCode();
+                exitCodeHandler.reset();
                 OutputService.clearTerminal();
                 this.#eventEmitter.addHandler(cancellationHandler);
                 this.#eventEmitter.addReporter(setupReporter);
@@ -6256,11 +6375,6 @@ class Cli {
             const runner = new Runner(resolvedConfig);
             await runner.run(testFiles, cancellationToken);
         } while (cancellationToken.getReason() === "configChange");
-        if (this.#deferredDiagnostics != null) {
-            OutputService.writeBlankLine();
-            OutputService.writeWarning(diagnosticText(this.#deferredDiagnostics));
-        }
-        this.#eventEmitter.removeHandlers();
     }
     #waitForChangedFiles(resolvedConfig, cancellationToken) {
         return new Promise((resolve) => {

package/dist/bin.js

@@ -3,4 +3,5 @@ import process from 'node:process';
 import { Cli } from './api.js';
 
 const cli = new Cli();
-await cli.run(process.argv.slice(2));
+const commandLine = process.argv.slice(2);
+process.exitCode = await cli.run(commandLine);

package/dist/index.d.cts

@@ -28,119 +28,84 @@ interface Describe {
      */
     todo: (name: string, callback?: () => void | Promise<void>) => void;
 }
-interface Test {
-    /**
-     * Defines a single test.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    (name: string, callback: () => void | Promise<void>): void;
-    /**
-     * Marks a test as focused.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    only: (name: string, callback: () => void | Promise<void>) => void;
-    /**
-     * Marks a test as skipped.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    skip: (name: string, callback: () => void | Promise<void>) => void;
-    /**
-     * Marks a test as yet to be implemented.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    todo: (name: string, callback?: () => void | Promise<void>) => void;
-}
+
 interface Matchers {
     /**
-     * Checks if the JSX component accepts props of the given type.
-     *
-     * @remarks
-     *
-     * This is a work in progress feature. Generic components are not yet supported.
+     * Checks if the type is the same as the given type.
      */
-    toAcceptProps: {
+    toBe: {
         /**
-         * Checks if the JSX component accepts props of the given type.
-         *
-         * @remarks
-         *
-         * This is a work in progress feature. Generic components are not yet supported.
+         * Checks if the type is the same as the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the JSX component accepts the given props.
-         *
-         * @remarks
-         *
-         * This is a work in progress feature. Generic components are not yet supported.
+         * Checks if the type is the same as type of the given expression.
          */
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is the same as the target type.
+     * Checks if the type is assignable from the given type.
      */
-    toBe: {
+    toBeAssignableFrom: {
         /**
-         * Checks if the source type is the same as the target type.
+         * Checks if the type is assignable from the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is the same as type of the target expression.
+         * Checks if the type is assignable from type of the given expression.
          */
         (target: unknown): void;
     };
     /**
-     * Checks if the decorator function can be applied.
+     * Checks if the type is assignable to the given type.
      */
-    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
-    /**
-     * Checks if the source type is assignable from the target type.
-     */
-    toBeAssignableFrom: {
+    toBeAssignableTo: {
         /**
-         * Checks if the source type is assignable from the target type.
+         * Checks if the type is assignable to the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is assignable from type of the target expression.
+         * Checks if the type is assignable to type of the given expression.
          */
         (target: unknown): void;
     };
+}
+interface Matchers {
     /**
-     * Checks if the source type is assignable to the target type.
+     * Checks if the JSX component accepts the given props.
      */
-    toBeAssignableTo: {
+    toAcceptProps: {
         /**
-         * Checks if the source type is assignable to the target type.
+         * Checks if the JSX component accepts props of the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is assignable to type of the target expression.
+         * Checks if the JSX component accepts the given props.
          */
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is callable with the given arguments.
+     * Checks if the decorator is applicable to the given class or class member.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
+    /**
+     * Checks if the function is callable with the given arguments.
      */
     toBeCallableWith: (...args: Array<unknown>) => void;
     /**
-     * Checks if the source type is constructable with the given arguments.
+     * Checks if the class is constructable with the given arguments.
      */
     toBeConstructableWith: (...args: Array<unknown>) => void;
     /**
-     * Checks if a property key exists on the source type.
+     * Checks if the generic is instantiable with the given type arguments.
+     */
+    toBeInstantiableWith: <Target extends [...args: Array<unknown>]>() => void;
+    /**
+     * Checks if the type has the given property.
      */
     toHaveProperty: (key: string | number | symbol) => void;
     /**
-     * Checks if the source type raises an error.
+     * Checks if the type raises an error.
      */
     toRaiseError: (...target: Array<string | number | RegExp>) => void;
 }
@@ -203,6 +168,63 @@ interface Expect {
         (source: unknown): Modifier;
     };
 }
+
+interface Test {
+    /**
+     * Defines a single test.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    (name: string, callback: () => void | Promise<void>): void;
+    /**
+     * Marks a test as focused.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    only: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a test as skipped.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    skip: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a test as yet to be implemented.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    todo: (name: string, callback?: () => void | Promise<void>) => void;
+}
+
+interface Actions {
+    /**
+     * Calls the given function with the provided arguments.
+     */
+    isCalledWith: (...args: Array<unknown>) => void;
+}
+interface When {
+    /**
+     * Creates a test plan.
+     *
+     * @template Target - The type upon which an action is performed.
+     */
+    <Target>(): Actions;
+    /**
+     * Creates a test plan.
+     *
+     * @param target - The expression upon which an action is performed.
+     */
+    (target: unknown): Actions;
+}
+
+/**
+ * The fill-in type. Useful to fill in the required type arguments of generic types.
+ */
+type _ = never;
 /**
  * Builds an assertion.
  */
@@ -227,29 +249,10 @@ declare const it: Test;
  * Defines a single test.
  */
 declare const test: Test;
-interface Actions {
-    /**
-     * Calls the given function with the provided arguments.
-     */
-    isCalledWith: (...args: Array<unknown>) => void;
-}
-interface When {
-    /**
-     * Creates a test plan.
-     *
-     * @template Target - The type upon which an action is performed.
-     */
-    <Target>(): Actions;
-    /**
-     * Creates a test plan.
-     *
-     * @param target - The expression upon which an action is performed.
-     */
-    (target: unknown): Actions;
-}
 /**
  * Creates a test plan.
  */
 declare const when: When;
 
 export { describe, expect, it, omit, pick, test, when };
+export type { _ };

package/dist/index.d.ts

@@ -28,119 +28,84 @@ interface Describe {
      */
     todo: (name: string, callback?: () => void | Promise<void>) => void;
 }
-interface Test {
-    /**
-     * Defines a single test.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    (name: string, callback: () => void | Promise<void>): void;
-    /**
-     * Marks a test as focused.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    only: (name: string, callback: () => void | Promise<void>) => void;
-    /**
-     * Marks a test as skipped.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    skip: (name: string, callback: () => void | Promise<void>) => void;
-    /**
-     * Marks a test as yet to be implemented.
-     *
-     * @param name - The name of the test.
-     * @param callback - The function with a code snippet and assertions.
-     */
-    todo: (name: string, callback?: () => void | Promise<void>) => void;
-}
+
 interface Matchers {
     /**
-     * Checks if the JSX component accepts props of the given type.
-     *
-     * @remarks
-     *
-     * This is a work in progress feature. Generic components are not yet supported.
+     * Checks if the type is the same as the given type.
      */
-    toAcceptProps: {
+    toBe: {
         /**
-         * Checks if the JSX component accepts props of the given type.
-         *
-         * @remarks
-         *
-         * This is a work in progress feature. Generic components are not yet supported.
+         * Checks if the type is the same as the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the JSX component accepts the given props.
-         *
-         * @remarks
-         *
-         * This is a work in progress feature. Generic components are not yet supported.
+         * Checks if the type is the same as type of the given expression.
          */
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is the same as the target type.
+     * Checks if the type is assignable from the given type.
      */
-    toBe: {
+    toBeAssignableFrom: {
         /**
-         * Checks if the source type is the same as the target type.
+         * Checks if the type is assignable from the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is the same as type of the target expression.
+         * Checks if the type is assignable from type of the given expression.
          */
         (target: unknown): void;
     };
     /**
-     * Checks if the decorator function can be applied.
+     * Checks if the type is assignable to the given type.
      */
-    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
-    /**
-     * Checks if the source type is assignable from the target type.
-     */
-    toBeAssignableFrom: {
+    toBeAssignableTo: {
         /**
-         * Checks if the source type is assignable from the target type.
+         * Checks if the type is assignable to the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is assignable from type of the target expression.
+         * Checks if the type is assignable to type of the given expression.
          */
         (target: unknown): void;
     };
+}
+interface Matchers {
     /**
-     * Checks if the source type is assignable to the target type.
+     * Checks if the JSX component accepts the given props.
      */
-    toBeAssignableTo: {
+    toAcceptProps: {
         /**
-         * Checks if the source type is assignable to the target type.
+         * Checks if the JSX component accepts props of the given type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is assignable to type of the target expression.
+         * Checks if the JSX component accepts the given props.
          */
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is callable with the given arguments.
+     * Checks if the decorator is applicable to the given class or class member.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
+    /**
+     * Checks if the function is callable with the given arguments.
      */
     toBeCallableWith: (...args: Array<unknown>) => void;
     /**
-     * Checks if the source type is constructable with the given arguments.
+     * Checks if the class is constructable with the given arguments.
      */
     toBeConstructableWith: (...args: Array<unknown>) => void;
     /**
-     * Checks if a property key exists on the source type.
+     * Checks if the generic is instantiable with the given type arguments.
+     */
+    toBeInstantiableWith: <Target extends [...args: Array<unknown>]>() => void;
+    /**
+     * Checks if the type has the given property.
      */
     toHaveProperty: (key: string | number | symbol) => void;
     /**
-     * Checks if the source type raises an error.
+     * Checks if the type raises an error.
      */
     toRaiseError: (...target: Array<string | number | RegExp>) => void;
 }
@@ -203,6 +168,63 @@ interface Expect {
         (source: unknown): Modifier;
     };
 }
+
+interface Test {
+    /**
+     * Defines a single test.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    (name: string, callback: () => void | Promise<void>): void;
+    /**
+     * Marks a test as focused.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    only: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a test as skipped.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    skip: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a test as yet to be implemented.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    todo: (name: string, callback?: () => void | Promise<void>) => void;
+}
+
+interface Actions {
+    /**
+     * Calls the given function with the provided arguments.
+     */
+    isCalledWith: (...args: Array<unknown>) => void;
+}
+interface When {
+    /**
+     * Creates a test plan.
+     *
+     * @template Target - The type upon which an action is performed.
+     */
+    <Target>(): Actions;
+    /**
+     * Creates a test plan.
+     *
+     * @param target - The expression upon which an action is performed.
+     */
+    (target: unknown): Actions;
+}
+
+/**
+ * The fill-in type. Useful to fill in the required type arguments of generic types.
+ */
+type _ = never;
 /**
  * Builds an assertion.
  */
@@ -227,29 +249,10 @@ declare const it: Test;
  * Defines a single test.
  */
 declare const test: Test;
-interface Actions {
-    /**
-     * Calls the given function with the provided arguments.
-     */
-    isCalledWith: (...args: Array<unknown>) => void;
-}
-interface When {
-    /**
-     * Creates a test plan.
-     *
-     * @template Target - The type upon which an action is performed.
-     */
-    <Target>(): Actions;
-    /**
-     * Creates a test plan.
-     *
-     * @param target - The expression upon which an action is performed.
-     */
-    (target: unknown): Actions;
-}
 /**
  * Creates a test plan.
  */
 declare const when: When;
 
 export { describe, expect, it, omit, pick, test, when };
+export type { _ };

package/dist/tag.js

@@ -1,31 +1,10 @@
-import { Cli, EventEmitter, CancellationToken } from './api.js';
+import { Cli } from './api.js';
 
-class StatusHandler {
-    #hasError = false;
-    hasError() {
-        return this.#hasError;
-    }
-    on([event, payload]) {
-        if (event === "run:start") {
-            this.#hasError = false;
-            return;
-        }
-        if ("diagnostics" in payload) {
-            if (payload.diagnostics.some((diagnostic) => diagnostic.category === "error")) {
-                this.#hasError = true;
-            }
-        }
-    }
-}
 async function tstyche(template, ...substitutions) {
-    const cli = new Cli({ noErrorExitCode: true });
+    const cli = new Cli();
     const commandLine = String.raw(template, ...substitutions).split(/\s+/);
-    const eventEmitter = new EventEmitter();
-    const statusHandler = new StatusHandler();
-    eventEmitter.addHandler(statusHandler);
-    await cli.run(commandLine, new CancellationToken());
-    eventEmitter.removeHandler(statusHandler);
-    if (statusHandler.hasError()) {
+    const exitCode = await cli.run(commandLine);
+    if (exitCode > 0) {
         throw new Error("TSTyche test run failed. Check the output above for details.");
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "7.0.0-beta.2",
+  "version": "7.0.0-beta.4",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",

package/schemas/config.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "checkDeclarationFiles": {
+      "description": "Check declaration files for type errors.",
+      "default": true,
+      "type": "boolean"
+    },
+    "checkSuppressedErrors": {
+      "description": "Check errors silenced by '@ts-expect-error' directives.",
+      "default": true,
+      "type": "boolean"
+    },
+    "failFast": {
+      "description": "Stop running tests after the first failed assertion.",
+      "default": false,
+      "type": "boolean"
+    },
+    "fixtureFileMatch": {
+      "description": "The list of glob patterns matching the fixture files.",
+      "default": [
+        "**/__fixtures__/*.{ts,tsx}",
+        "**/fixtures/*.{ts,tsx}"
+      ],
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "type": "string"
+      }
+    },
+    "quiet": {
+      "description": "Silence all test runner output except errors and warnings.",
+      "default": false,
+      "type": "boolean"
+    },
+    "rejectAnyType": {
+      "description": "Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.",
+      "default": true,
+      "type": "boolean"
+    },
+    "rejectNeverType": {
+      "description": "Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.",
+      "default": true,
+      "type": "boolean"
+    },
+    "reporters": {
+      "description": "The list of reporters to use.",
+      "default": [
+        "list",
+        "summary"
+      ],
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "type": "string"
+      }
+    },
+    "target": {
+      "description": "The range of TypeScript versions to test against.",
+      "default": "*",
+      "type": "string"
+    },
+    "testFileMatch": {
+      "description": "The list of glob patterns matching the test files.",
+      "default": [
+        "**/*.tst.*",
+        "**/__typetests__/*.test.*",
+        "**/typetests/*.test.*"
+      ],
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "type": "string"
+      }
+    },
+    "tsconfig": {
+      "description": "The TSConfig to load.",
+      "default": "findup",
+      "type": "string"
+    },
+    "verbose": {
+      "description": "Enable detailed logging.",
+      "default": false,
+      "type": "boolean"
+    }
+  }
+}