tstyche 6.0.0-rc.0 → 6.0.0

package/README.md

@@ -13,7 +13,7 @@ TSTyche is a type testing tool for TypeScript. It ships with `describe()` and `t
 
 ## Helpers
 
-If you are used to test JavaScript, a simple type test file should look familiar:
+If you are used to testing, a type test should look familiar:
 
 ```ts
 import { expect, test } from "tstyche";
@@ -30,42 +30,33 @@ test("isSameLength", () => {
 });
 ```
 
-To organize, debug and plan tests TSTyche has:
+To group and organize tests, TSTyche has:
 
 - `test()`, `it()` and `describe()` helpers,
 - with `.only`, `.skip` and `.todo` run mode flags.
 
 ## Assertions
 
-The assertions can be used to write type tests (like in the above example) or mixed in your unit tests:
+The `expect` style assertions can check either the inferred type of an expression (as in the example above) or a type directly:
 
 ```ts
-import assert from "node:assert";
-import test from "node:test";
-import * as tstyche from "tstyche";
+import { expect } from "tstyche";
 
-function toMilliseconds(value: number) {
-  if (typeof value === "number" && !Number.isNaN(value)) {
-    return value * 1000;
-  }
+type AsyncProps<T> = {
+  [K in keyof T]+?: T[K] | Promise<T[K]>;
+};
 
-  throw new Error("Not a number");
-}
-
-test("toMilliseconds", () => {
-  const sample = toMilliseconds(10);
+type WithLoading<T> = T & { loading: boolean };
 
-  assert.equal(sample, 10_000);
-  tstyche.expect(sample).type.toBe<number>();
-
-  // Will pass as a type test and not throw at runtime
-  tstyche.expect(toMilliseconds).type.not.toBeCallableWith("20");
-});
+expect<WithLoading<AsyncProps<{ query: string }>>>().type.toBe<{
+  query?: string | Promise<string>;
+  loading: boolean;
+}>();
 ```
 
 Here is the list of all matchers:
 
-- `.toBe()`, `.toBeAssignableFrom()`, `.toBeAssignableTo()` compare types or types of expression,
+- `.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,
@@ -74,13 +65,23 @@ Here is the list of all matchers:
 
 ## Runner
 
-The `tstyche` command is the heart of TSTyche. For example, it can select test files by path, filter tests by name and to run the tests against specific versions of TypeScript:
+The `tstyche` command is the heart of TSTyche. It allows you to select test files by path, filter tests by name and run them against specific versions of TypeScript:
 
 ```shell
 tstyche query-params --only multiple --target '>=5.6'
 ```
 
-This simple! (And it has watch mode too.)
+It is that simple! Actually, TSTyche does even more:
+
+- checks messages of errors suppressed by `// @ts-expect-error`,
+- generates type tests from a data table,
+- runs tests in watch mode.
+
+## Try It Out
+
+Try TSTyche online on StackBlitz:
+
+[![Open in StackBlitz][starter-badge]][starter-url]
 
 ## Documentation
 
@@ -98,3 +99,5 @@ Visit [tstyche.org](https://tstyche.org) to view the full documentation.
 [install-size-url]: https://packagephobia.com/result?p=tstyche
 [coverage-badge]: https://badgen.net/codacy/coverage/a581ca5c323a455886b7bdd9623c4ec8
 [coverage-url]: https://app.codacy.com/gh/tstyche/tstyche/coverage/dashboard
+[starter-badge]: https://developer.stackblitz.com/img/open_in_stackblitz.svg
+[starter-url]: https://stackblitz.com/fork/github/tstyche/tstyche-starter?file=README.md&title=TSTyche%20Starter%20Project&view=editor

package/dist/tstyche.js

@@ -4550,9 +4550,9 @@ class ToAcceptProps {
     }
 }
 
-function containsInstantiableType(target, compiler) {
+function containsInstantiable(target, compiler) {
     return ("types" in target &&
-        target.types.some((type) => type.flags & compiler.TypeFlags.InstantiableNonPrimitive));
+        target.types.some((type) => type.flags & compiler.TypeFlags.Instantiable));
 }
 function getIndexSignatures(type, compiler, typeChecker) {
     if (type.flags & compiler.TypeFlags.Intersection) {
@@ -4713,7 +4713,7 @@ class Structure {
                     return true;
                 }
             }
-            if (containsInstantiableType(a, this.#compiler) || containsInstantiableType(b, this.#compiler)) {
+            if (containsInstantiable(a, this.#compiler) || containsInstantiable(b, this.#compiler)) {
                 return false;
             }
             if ((a.flags & b.flags) | this.#compiler.TypeFlags.StructuredType) {
@@ -5049,8 +5049,8 @@ class Structure {
             return type.regularType;
         }
         if (type.flags & this.#compiler.TypeFlags.UnionOrIntersection) {
-            const candidateType = this.#normalize(type.types[0]);
-            if (type.types.every((t) => this.compare(this.#normalize(t), candidateType))) {
+            const candidateType = type.types[0];
+            if (type.types.every((t) => this.compare(t, candidateType))) {
                 return candidateType;
             }
         }
@@ -5912,7 +5912,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.0-rc.0";
+    static version = "6.0.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "6.0.0-rc.0",
+  "version": "6.0.0",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",