tstyche 7.0.0-beta.1 → 7.0.0-beta.3

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
 
@@ -73,7 +81,7 @@ tstyche query-params --only multiple --target '>=5.6'
 
 It is that simple! Actually, TSTyche does even more:
 
-- checks messages of errors suppressed by `// @ts-expect-error`,
+- checks messages of errors suppressed by `@ts-expect-error` directives,
 - generates type tests from a data table,
 - runs tests in watch mode.
 

package/dist/{tstyche.js → api.js}

@@ -1038,7 +1038,7 @@ class Options {
         },
         {
             brand: "boolean",
-            description: "Check errors silenced by '// @ts-expect-error' directives.",
+            description: "Check errors silenced by '@ts-expect-error' directives.",
             group: 4,
             name: "checkSuppressedErrors",
         },
@@ -3450,6 +3450,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];
@@ -3566,7 +3611,7 @@ class SourceTextEditor {
 class SuppressedLayer {
     #compiler;
     #editor;
-    #expectErrorRegex = /^(\s*)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
+    #expectErrorRegex = /^([ \t/*{]*)(@ts-expect-error)(!?)(:? *)(.*?)(?:\*\/.*)?$/gim;
     #resolvedConfig;
     #suppressedErrorsMap;
     constructor(compiler, editor, resolvedConfig) {
@@ -4327,10 +4372,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 +4397,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 +4426,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.`;
     }
@@ -5335,7 +5399,7 @@ class AbilityMatcherBase {
     constructor(compiler) {
         this.compiler = compiler;
     }
-    #resolveTargetText(nodes) {
+    getArgumentCountText(nodes) {
         if (nodes.length === 0) {
             return "without arguments";
         }
@@ -5344,15 +5408,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 +5437,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 +5464,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 +5491,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 +5673,7 @@ class ExpectService {
     toBeAssignableTo;
     toBeCallableWith;
     toBeConstructableWith;
+    toBeInstantiableWith;
     toHaveProperty;
     toRaiseError;
     constructor(compiler, program, reject) {
@@ -5585,6 +5687,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 +5697,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 +5719,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 +5810,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 +5936,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 +6176,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "7.0.0-beta.1";
+    static version = "7.0.0-beta.3";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -6205,7 +6316,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));

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import process from 'node:process';
-import { Cli } from './tstyche.js';
+import { Cli } from './api.js';
 
 const cli = new Cli();
 await cli.run(process.argv.slice(2));

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,4 +1,4 @@
-import { Cli, EventEmitter, CancellationToken } from './tstyche.js';
+import { Cli, EventEmitter, CancellationToken } from './api.js';
 
 class StatusHandler {
     #hasError = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "7.0.0-beta.1",
+  "version": "7.0.0-beta.3",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",
@@ -25,8 +25,8 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./api": "./dist/api.js",
     "./tag": "./dist/tag.js",
-    "./tstyche": "./dist/tstyche.js",
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",