chore: update TSTyche to v5 (#15929)

Author: mrazauskas

.github/workflows/nodejs.yml

@@ -48,7 +48,7 @@ jobs:
       - name: ts integration
         run: yarn test-ts --selectProjects ts-integration
       - name: type tests
-        run: yarn test-types --target '>=5.4' # For documentation, see: https://tstyche.org/guide/typescript-versions
+        run: yarn test-types --target '>=5.4' # For documentation, see: https://tstyche.org/guides/typescript-versions
       - name: verify TypeScript@5.4 compatibility
         run: yarn verify-old-ts
       - name: run ESLint with type info

package.json

@@ -78,7 +78,7 @@
     "strip-json-comments": "^3.1.1",
     "tempy": "^1.0.1",
     "ts-node": "^10.5.0",
-    "tstyche": "^4.0.0",
+    "tstyche": "^5.0.0",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.38.0",
     "webpack": "^5.68.0",

packages/expect/__typetests__/expect.test.ts

@@ -162,7 +162,7 @@ describe('MatcherFunction', () => {
       };
     };
 
-    expect<ToBeWithinRange>().type.toBeAssignableWith(toBeWithinRange);
+    expect<ToBeWithinRange>().type.toBeAssignableFrom(toBeWithinRange);
   });
 
   test('requires the `actual` argument to be of type `unknown`', () => {
@@ -173,7 +173,7 @@ describe('MatcherFunction', () => {
       };
     };
 
-    expect<MatcherFunction>().type.not.toBeAssignableWith(actualMustBeUnknown);
+    expect<MatcherFunction>().type.not.toBeAssignableFrom(actualMustBeUnknown);
   });
 
   test('allows omitting the `expected` argument', () => {
@@ -193,7 +193,7 @@ describe('MatcherFunction', () => {
       };
     };
 
-    expect<AllowOmittingExpected>().type.toBeAssignableWith(
+    expect<AllowOmittingExpected>().type.toBeAssignableFrom(
       allowOmittingExpected,
     );
   });
@@ -205,7 +205,7 @@ describe('MatcherFunction', () => {
       };
     };
 
-    expect<MatcherFunction>().type.not.toBeAssignableWith(lacksMessage);
+    expect<MatcherFunction>().type.not.toBeAssignableFrom(lacksMessage);
   });
 
   test('the `pass` property is required in the return type', () => {
@@ -215,7 +215,7 @@ describe('MatcherFunction', () => {
       };
     };
 
-    expect<MatcherFunction>().type.not.toBeAssignableWith(lacksPass);
+    expect<MatcherFunction>().type.not.toBeAssignableFrom(lacksPass);
   });
 
   test('context is defined inside a matcher function', () => {
@@ -283,7 +283,7 @@ describe('MatcherFunction', () => {
       };
     };
 
-    expect<CustomStateAndExpected>().type.toBeAssignableWith(
+    expect<CustomStateAndExpected>().type.toBeAssignableFrom(
       customContextAndExpected,
     );
   });

packages/jest-mock/__typetests__/Mocked.test.ts

@@ -66,7 +66,7 @@ describe('Mocked', () => {
       return;
     });
 
-    expect(new SomeClass('sample')).type.toBeAssignableWith(mockSomeInstance);
+    expect(new SomeClass('sample')).type.toBeAssignableFrom(mockSomeInstance);
   });
 
   test('wraps a function type with type definitions of the Jest mock function', () => {
@@ -83,7 +83,7 @@ describe('Mocked', () => {
       (a: boolean, b?: number) => true,
     );
 
-    expect(someFunction).type.toBeAssignableWith(mockFunction);
+    expect(someFunction).type.toBeAssignableFrom(mockFunction);
   });
 
   test('wraps an async function type with type definitions of the Jest mock function', () => {
@@ -102,7 +102,7 @@ describe('Mocked', () => {
       (a: Array<boolean>) => Promise.resolve(true),
     );
 
-    expect(someAsyncFunction).type.toBeAssignableWith(mockAsyncFunction);
+    expect(someAsyncFunction).type.toBeAssignableFrom(mockAsyncFunction);
   });
 
   test('wraps a function object type with type definitions of the Jest mock function', () => {
@@ -144,7 +144,7 @@ describe('Mocked', () => {
       return;
     });
 
-    expect(someFunctionObject).type.toBeAssignableWith(mockFunctionObject);
+    expect(someFunctionObject).type.toBeAssignableFrom(mockFunctionObject);
   });
 
   test('wraps an object type with type definitions of the Jest mock function', () => {
@@ -253,16 +253,16 @@ describe('Mocked', () => {
       mockObject.someClassInstance.methodB.mockImplementation,
     ).type.not.toBeCallableWith((a: number) => 123);
 
-    expect(someObject).type.toBeAssignableWith(mockObject);
+    expect(someObject).type.toBeAssignableFrom(mockObject);
   });
 
   test('wraps the global `console` object type with type definitions of the Jest mock function', () => {
     const mockConsole = console as Mocked<typeof console>;
 
-    expect(console.log).type.toBeAssignableWith(
+    expect(console.log).type.toBeAssignableFrom(
       mockConsole.log.mockImplementation(() => {}),
     );
-    expect<MockInstance<typeof console.log>>().type.toBeAssignableWith(
+    expect<MockInstance<typeof console.log>>().type.toBeAssignableFrom(
       mockConsole.log.mockImplementation(() => {}),
     );
   });

packages/jest-mock/__typetests__/utility-types.test.ts

@@ -108,29 +108,29 @@ type IndexObject = {
 };
 
 test('ClassLike', () => {
-  expect<ClassLike>().type.toBeAssignableWith(SomeClass);
+  expect<ClassLike>().type.toBeAssignableFrom(SomeClass);
 
-  expect<ClassLike>().type.not.toBeAssignableWith(() => {});
-  expect<ClassLike>().type.not.toBeAssignableWith(function abc() {
+  expect<ClassLike>().type.not.toBeAssignableFrom(() => {});
+  expect<ClassLike>().type.not.toBeAssignableFrom(function abc() {
     return;
   });
-  expect<ClassLike>().type.not.toBeAssignableWith('abc');
-  expect<ClassLike>().type.not.toBeAssignableWith(123);
-  expect<ClassLike>().type.not.toBeAssignableWith(false);
-  expect<ClassLike>().type.not.toBeAssignableWith(someObject);
+  expect<ClassLike>().type.not.toBeAssignableFrom('abc');
+  expect<ClassLike>().type.not.toBeAssignableFrom(123);
+  expect<ClassLike>().type.not.toBeAssignableFrom(false);
+  expect<ClassLike>().type.not.toBeAssignableFrom(someObject);
 });
 
 test('FunctionLike', () => {
-  expect<FunctionLike>().type.toBeAssignableWith(() => {});
-  expect<FunctionLike>().type.toBeAssignableWith(function abc() {
+  expect<FunctionLike>().type.toBeAssignableFrom(() => {});
+  expect<FunctionLike>().type.toBeAssignableFrom(function abc() {
     return;
   });
 
-  expect<FunctionLike>().type.not.toBeAssignableWith('abc');
-  expect<FunctionLike>().type.not.toBeAssignableWith(123);
-  expect<FunctionLike>().type.not.toBeAssignableWith(false);
-  expect<FunctionLike>().type.not.toBeAssignableWith(SomeClass);
-  expect<FunctionLike>().type.not.toBeAssignableWith(someObject);
+  expect<FunctionLike>().type.not.toBeAssignableFrom('abc');
+  expect<FunctionLike>().type.not.toBeAssignableFrom(123);
+  expect<FunctionLike>().type.not.toBeAssignableFrom(false);
+  expect<FunctionLike>().type.not.toBeAssignableFrom(SomeClass);
+  expect<FunctionLike>().type.not.toBeAssignableFrom(someObject);
 });
 
 test('ConstructorKeys', () => {

packages/jest-resolve/__typetests__/resolver.test.ts

@@ -16,15 +16,15 @@ import type {
 
 // PackageJSON
 
-expect<PackageJSON>().type.toBeAssignableWith({
+expect<PackageJSON>().type.toBeAssignableFrom({
   caption: 'test',
   count: 100,
   isTest: true,
   location: {name: 'test', start: [1, 2], valid: false, x: 10, y: 20},
   values: [0, 10, 20, {x: 1, y: 2}, true, 'test', ['a', 'b']],
 });
 
-expect<PackageJSON>().type.not.toBeAssignableWith({
+expect<PackageJSON>().type.not.toBeAssignableFrom({
   filter: () => {},
 });
 
@@ -33,15 +33,15 @@ expect<PackageJSON>().type.not.toBeAssignableWith({
 function customSyncResolver(path: string, options: ResolverOptions): string {
   return path;
 }
-expect<SyncResolver>().type.toBeAssignableWith(customSyncResolver);
+expect<SyncResolver>().type.toBeAssignableFrom(customSyncResolver);
 
 async function customAsyncResolver(
   path: string,
   options: ResolverOptions,
 ): Promise<string> {
   return path;
 }
-expect<AsyncResolver>().type.toBeAssignableWith(customAsyncResolver);
+expect<AsyncResolver>().type.toBeAssignableFrom(customAsyncResolver);
 
 // AsyncResolver
 
@@ -60,7 +60,7 @@ const asyncResolver: AsyncResolver = async (path, options) => {
 };
 
 const notReturningAsyncResolver = async () => {};
-expect<AsyncResolver>().type.not.toBeAssignableWith(
+expect<AsyncResolver>().type.not.toBeAssignableFrom(
   notReturningAsyncResolver(),
 );
 
@@ -81,14 +81,14 @@ const syncResolver: SyncResolver = (path, options) => {
 };
 
 const notReturningSyncResolver = () => {};
-expect<SyncResolver>().type.not.toBeAssignableWith(notReturningSyncResolver());
+expect<SyncResolver>().type.not.toBeAssignableFrom(notReturningSyncResolver());
 
 // JestResolver
 
-expect<JestResolver>().type.toBeAssignableWith({async: asyncResolver});
-expect<JestResolver>().type.toBeAssignableWith({sync: syncResolver});
-expect<JestResolver>().type.toBeAssignableWith({
+expect<JestResolver>().type.toBeAssignableFrom({async: asyncResolver});
+expect<JestResolver>().type.toBeAssignableFrom({sync: syncResolver});
+expect<JestResolver>().type.toBeAssignableFrom({
   async: asyncResolver,
   sync: syncResolver,
 });
-expect<JestResolver>().type.not.toBeAssignableWith({});
+expect<JestResolver>().type.not.toBeAssignableFrom({});

packages/jest-snapshot/__typetests__/SnapshotResolver.test.ts

@@ -28,65 +28,65 @@ const snapshotResolver: SnapshotResolver = {
 
 // resolveSnapshotPath
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: (testPath: string, snapshotExtension: boolean) =>
     'snapshot/path',
   resolveTestPath: () => 'test/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: (testPath: boolean) => 'snapshot/path',
   resolveTestPath: () => 'test/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => true,
   resolveTestPath: () => 'test/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveTestPath: () => 'test/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
 // resolveTestPath
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => 'snapshot/path',
   resolveTestPath: (snapshotPath: string, snapshotExtension: boolean) =>
     'test/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => 'snapshot/path',
   resolveTestPath: (snapshotPath: boolean) => 'test/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => 'snapshot/path',
   resolveTestPath: () => true,
   testPathForConsistencyCheck: 'test/path/example',
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => 'snapshot/path',
   testPathForConsistencyCheck: 'test/path/example',
 });
 
 // testPathForConsistencyCheck
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => 'snapshot/path',
   resolveTestPath: () => 'test/path',
   testPathForConsistencyCheck: true,
 });
 
-expect<SnapshotResolver>().type.not.toBeAssignableWith({
+expect<SnapshotResolver>().type.not.toBeAssignableFrom({
   resolveSnapshotPath: () => 'snapshot/path',
   resolveTestPath: () => 'test/path',
 });

packages/jest-types/__typetests__/config.test.ts

@@ -12,7 +12,7 @@ const config: Config = {};
 
 describe('Config', () => {
   test('coverageThreshold', () => {
-    expect(config).type.toBeAssignableWith({
+    expect(config).type.toBeAssignableFrom({
       coverageThreshold: {
         './src/api/very-important-module.js': {
           branches: 100,
@@ -56,7 +56,7 @@ describe('Config', () => {
       'clearTimeout' as const,
     ];
 
-    expect(config).type.toBeAssignableWith({
+    expect(config).type.toBeAssignableFrom({
       fakeTimers: {
         advanceTimers: true,
         doNotFake,
@@ -66,48 +66,48 @@ describe('Config', () => {
       },
     });
 
-    expect(config).type.toBeAssignableWith({
+    expect(config).type.toBeAssignableFrom({
       fakeTimers: {
         advanceTimers: 40,
         now: Date.now(),
       },
     });
 
-    expect(config).type.not.toBeAssignableWith({
+    expect(config).type.not.toBeAssignableFrom({
       fakeTimers: {
         now: new Date(),
       },
     });
 
-    expect(config).type.toBeAssignableWith({
+    expect(config).type.toBeAssignableFrom({
       fakeTimers: {
         enableGlobally: true,
         legacyFakeTimers: true as const,
       },
     });
 
-    expect(config).type.not.toBeAssignableWith({
+    expect(config).type.not.toBeAssignableFrom({
       fakeTimers: {
         advanceTimers: true,
         legacyFakeTimers: true as const,
       },
     });
 
-    expect(config).type.not.toBeAssignableWith({
+    expect(config).type.not.toBeAssignableFrom({
       fakeTimers: {
         doNotFake,
         legacyFakeTimers: true as const,
       },
     });
 
-    expect(config).type.not.toBeAssignableWith({
+    expect(config).type.not.toBeAssignableFrom({
       fakeTimers: {
         legacyFakeTimers: true as const,
         now: 1_483_228_800_000,
       },
     });
 
-    expect(config).type.not.toBeAssignableWith({
+    expect(config).type.not.toBeAssignableFrom({
       fakeTimers: {
         legacyFakeTimers: true as const,
         timerLimit: 1000,
@@ -116,7 +116,7 @@ describe('Config', () => {
   });
 
   test('projects', () => {
-    expect(config).type.toBeAssignableWith({
+    expect(config).type.toBeAssignableFrom({
       projects: [
         // projects can be globs or objects
         './src/**',