tstyche 6.0.0-rc.0 → 6.0.1

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://tstyche.org/new

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) {
@@ -4587,9 +4587,6 @@ function getTargetSymbol(symbol, compiler) {
 function isCheckFlagSet(symbol, flag, compiler) {
     return !!(symbol.flags & compiler.SymbolFlags.Transient && symbol.links.checkFlags & flag);
 }
-function isSymbolFromDefaultLibrary(symbol, program) {
-    return !!symbol.declarations?.every((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
-}
 
 function getParameterFactsFromTuple(type, position, compiler) {
     return {
@@ -4677,13 +4674,11 @@ class SeenService {
 class Structure {
     #compiler;
     #compilerOptions;
-    #program;
     #seen = new SeenService();
     #typeChecker;
     constructor(compiler, program) {
         this.#compiler = compiler;
         this.#compilerOptions = program.getCompilerOptions();
-        this.#program = program;
         this.#typeChecker = program.getTypeChecker();
     }
     #compareMaybeNullish(a, b) {
@@ -4713,7 +4708,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) {
@@ -4791,9 +4786,8 @@ class Structure {
     }
     compareObjects(a, b) {
         if (a.objectFlags & b.objectFlags & this.#compiler.ObjectFlags.Reference) {
-            const isSame = this.compareTypeReferences(a, b);
-            if (isSame != null) {
-                return isSame;
+            if (!((a.objectFlags | b.objectFlags) & this.#compiler.ObjectFlags.ClassOrInterface)) {
+                return this.compareTypeReferences(a, b);
             }
         }
         return this.compareStructuredTypes(a, b);
@@ -4805,21 +4799,20 @@ class Structure {
             }
             return false;
         }
-        if ((a.objectFlags | b.objectFlags) & this.#compiler.ObjectFlags.Class) {
+        if (!this.compare(a.target, b.target)) {
             return this.compareStructuredTypes(a, b);
         }
-        if (a.symbol !== b.symbol) {
-            if (isSymbolFromDefaultLibrary(a.symbol, this.#program) || isSymbolFromDefaultLibrary(b.symbol, this.#program)) {
-                return false;
-            }
-            return;
-        }
         const aTypeArguments = this.#typeChecker.getTypeArguments(a);
         const bTypeArguments = this.#typeChecker.getTypeArguments(b);
         if (aTypeArguments.length !== bTypeArguments.length) {
             return false;
         }
-        return aTypeArguments.every((type, i) => this.compare(type, bTypeArguments[i]));
+        for (let i = 0; i < aTypeArguments.length; i++) {
+            if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
+                return false;
+            }
+        }
+        return true;
     }
     compareTuples(a, b) {
         if (a.target.readonly !== b.target.readonly) {
@@ -5049,8 +5042,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 +5905,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.0-rc.0";
+    static version = "6.0.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

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