fix deprecations

mokevnin · mokevnin · commit 964dd43bfd60 · 2025-08-13T17:22:23.000-04:00
Signed-off-by: Kirill Mokevnin &lt;mokevnin@gmail.com&gt;
diff --git a/modules/10-basics/20-typescript-as-a-second-language/test.ts b/modules/10-basics/20-typescript-as-a-second-language/test.ts
@@ -5,5 +5,5 @@ import multiply from './index';
 test('multiply', () => {
   expect(multiply(1, 3)).toBe(3);
 
-  expectTypeOf(multiply).returns.toMatchTypeOf<number>();
+  expectTypeOf(multiply).returns.toExtend<number>();
 });
diff --git a/modules/10-basics/30-variables/test.ts b/modules/10-basics/30-variables/test.ts
@@ -7,5 +7,5 @@ test('repeat', () => {
   expect(repeat('s', 2)).toBe('ss');
   expect(repeat('s', 0)).toBe('');
 
-  expectTypeOf(repeat).returns.toMatchTypeOf<string>();
+  expectTypeOf(repeat).returns.toExtend<string>();
 });
diff --git a/modules/10-basics/40-named-functions/test.ts b/modules/10-basics/40-named-functions/test.ts
@@ -8,5 +8,5 @@ test('getHiddenCard', () => {
   expect(getHiddenCard('1234123412344321', 2)).toEqual('**4321');
   expect(getHiddenCard('1234123412341234', 12)).toEqual('************1234');
 
-  expectTypeOf(getHiddenCard).returns.toMatchTypeOf<string>();
+  expectTypeOf(getHiddenCard).returns.toExtend<string>();
 });
diff --git a/modules/10-basics/45-anonymous-functions/test.ts b/modules/10-basics/45-anonymous-functions/test.ts
@@ -5,5 +5,5 @@ import getEvenNumbers from './index';
 test('function', () => {
   expect(getEvenNumbers()).toEqual([8, 100, 34]);
 
-  expectTypeOf(getEvenNumbers).returns.toMatchTypeOf<number[]>();
+  expectTypeOf(getEvenNumbers).returns.toExtend<number[]>();
 });
diff --git a/modules/10-basics/50-arrays/test.ts b/modules/10-basics/50-arrays/test.ts
@@ -14,5 +14,5 @@ test('function', () => {
 
   expect(filterAnagrams('laser', ['lazing', 'lazy', 'lacer'])).toEqual([]);
 
-  expectTypeOf(filterAnagrams).returns.toMatchTypeOf<string[]>();
+  expectTypeOf(filterAnagrams).returns.toExtend<string[]>();
 });
diff --git a/modules/10-basics/55-objects/test.ts b/modules/10-basics/55-objects/test.ts
@@ -21,8 +21,8 @@ test('function', () => {
   };
   expect(isComplete(course3)).toBe(true);
 
-  expectTypeOf(isComplete).returns.toMatchTypeOf<boolean>();
+  expectTypeOf(isComplete).returns.toExtend<boolean>();
   expectTypeOf(isComplete)
     .parameter(0)
-    .toMatchTypeOf<{ name: string; lessons: string[] }>();
+    .toExtend<{ name: string; lessons: string[] }>();
 });
diff --git a/modules/10-basics/60-enums/test.ts b/modules/10-basics/60-enums/test.ts
@@ -13,7 +13,7 @@ test('function', () => {
     status: ModalStatus.Closed,
   });
 
-  expectTypeOf(buildModal).returns.toMatchTypeOf<{
+  expectTypeOf(buildModal).returns.toExtend<{
     text: string;
     status: ModalStatus;
   }>();
diff --git a/modules/10-basics/70-type-aliases/test.ts b/modules/10-basics/70-type-aliases/test.ts
@@ -23,5 +23,5 @@ test('function', () => {
 
   expect(getOlderUser(user2, user3)).toBeNull();
 
-  expectTypeOf(getOlderUser).returns.toMatchTypeOf<User | null>();
+  expectTypeOf(getOlderUser).returns.toExtend<User | null>();
 });
diff --git a/modules/25-types/20-union-types/test.ts b/modules/25-types/20-union-types/test.ts
@@ -9,5 +9,5 @@ test('lastIndex', () => {
   expect(lastIndex(str, 'e')).toBe(5);
   expect(lastIndex(str, 'p')).toBeNull();
 
-  expectTypeOf(lastIndex).returns.toMatchTypeOf<number | null>();
+  expectTypeOf(lastIndex).returns.toExtend<number | null>();
 });
diff --git a/modules/25-types/25-literal-types/test.ts b/modules/25-types/25-literal-types/test.ts
@@ -25,5 +25,5 @@ test('startTurtleGame', () => {
   makeTurn('left');
   expect(state).toEqual([null, null, null, 'turtle', null]);
 
-  expectTypeOf(makeTurn).returns.toMatchTypeOf<void>();
+  expectTypeOf(makeTurn).returns.toExtend<void>();
 });
diff --git a/modules/25-types/40-assignability/test.ts b/modules/25-types/40-assignability/test.ts
@@ -9,6 +9,6 @@ test('form', () => {
   expect(nameValidator(form.name.value)).toBe(true);
   expect(ageValidator(form.age.value)).toBe(false);
 
-  expectTypeOf(nameValidator).parameters.toMatchTypeOf<[string]>();
-  expectTypeOf(ageValidator).parameters.toMatchTypeOf<[number]>();
+  expectTypeOf(nameValidator).parameters.toExtend<[string]>();
+  expectTypeOf(ageValidator).parameters.toExtend<[number]>();
 });
diff --git a/modules/25-types/70-variability/test.ts b/modules/25-types/70-variability/test.ts
@@ -39,5 +39,5 @@ test('applyTransactions', () => {
 
   expect(applyTransactions(wallet2)).toBe(10);
 
-  expectTypeOf(wallet2.transactions[0].apply).returns.toMatchTypeOf<number>();
+  expectTypeOf(wallet2.transactions[0].apply).returns.toExtend<number>();
 });
diff --git a/modules/35-interfaces/20-interface-using/test.ts b/modules/35-interfaces/20-interface-using/test.ts
@@ -8,9 +8,9 @@ test('guess who', () => {
 });
 
 test('Types check', () => {
-  expectTypeOf<ISuperman>().toMatchTypeOf<IBird>();
-  expectTypeOf<ISuperman>().toMatchTypeOf<IPlane>();
-  expectTypeOf(superMan).toMatchTypeOf<ISuperman>();
+  expectTypeOf<ISuperman>().toExtend<IBird>();
+  expectTypeOf<ISuperman>().toExtend<IPlane>();
+  expectTypeOf(superMan).toExtend<ISuperman>();
 
   expect(superMan).toHaveProperty('canFly');
   expect(superMan).toHaveProperty('isLiving');
diff --git a/modules/40-generics/10-generics-overview/test.ts b/modules/40-generics/10-generics-overview/test.ts
@@ -7,5 +7,5 @@ test('function', () => {
   expect(last([3, 4])).toBe(4);
   expect(last(['cat', 'dog'])).toBe('dog');
 
-  expectTypeOf(last<number>).returns.toMatchTypeOf<number | null>();
+  expectTypeOf(last<number>).returns.toExtend<number | null>();
 });
diff --git a/modules/40-generics/20-generic-types/test.ts b/modules/40-generics/20-generic-types/test.ts
@@ -18,8 +18,8 @@ test('function', () => {
   s1.add(1);
   expect(s1.has(1)).toBe(true);
 
-  expectTypeOf(s1.has).parameters.toMatchTypeOf<[number]>();
-  expectTypeOf(s1.add).parameters.toMatchTypeOf<[number]>();
+  expectTypeOf(s1.has).parameters.toExtend<[number]>();
+  expectTypeOf(s1.add).parameters.toExtend<[number]>();
 });
 
 test('function', () => {
@@ -38,6 +38,6 @@ test('function', () => {
   s1.add('hexlet');
   expect(s1.has('hexlet')).toBe(true);
 
-  expectTypeOf(s1.has).parameters.toMatchTypeOf<[string]>();
-  expectTypeOf(s1.add).parameters.toMatchTypeOf<[string]>();
+  expectTypeOf(s1.has).parameters.toExtend<[string]>();
+  expectTypeOf(s1.add).parameters.toExtend<[string]>();
 });
diff --git a/modules/40-generics/30-generic-functions/test.ts b/modules/40-generics/30-generic-functions/test.ts
@@ -18,7 +18,7 @@ test('MyArray', () => {
   expect(coll.push(2)).toBe(2);
   expect(coll.push(5)).toBe(3);
 
-  expectTypeOf(coll.push).parameters.toMatchTypeOf<[number]>();
+  expectTypeOf(coll.push).parameters.toExtend<[number]>();
 
   const coll1: MyArray<string> = {
     items: [],
@@ -31,5 +31,5 @@ test('MyArray', () => {
     },
   };
 
-  expectTypeOf(coll1.push).parameters.toMatchTypeOf<[string]>();
+  expectTypeOf(coll1.push).parameters.toExtend<[string]>();
 });
diff --git a/modules/40-generics/40-many-parameters/test.ts b/modules/40-generics/40-many-parameters/test.ts
@@ -20,6 +20,6 @@ test('MyMap', () => {
   expect(map.get('two')).toBe(2);
   expect(map.get('three')).toBe(undefined);
 
-  expectTypeOf(map.set).parameters.toMatchTypeOf<[string, number]>();
-  expectTypeOf(map.get).returns.toMatchTypeOf<number | undefined>();
+  expectTypeOf(map.set).parameters.toExtend<[string, number]>();
+  expectTypeOf(map.get).returns.toExtend<number | undefined>();
 });
diff --git a/modules/40-generics/50-async-functions/test.ts b/modules/40-generics/50-async-functions/test.ts
@@ -20,6 +20,6 @@ test('asyncMap', async () => {
   );
   expect(result3).toEqual([0, 2]);
 
-  expectTypeOf(result).toMatchTypeOf<number[]>();
-  expectTypeOf(result2).toMatchTypeOf<string[]>();
+  expectTypeOf(result).toExtend<number[]>();
+  expectTypeOf(result2).toExtend<string[]>();
 });
diff --git a/modules/50-objects/30-mapped-types/test.ts b/modules/50-objects/30-mapped-types/test.ts
@@ -16,7 +16,7 @@ test('sanitize', () => {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const user = sanitize(obj, ['password']);
 
-  expectTypeOf(user).toMatchTypeOf<{ name: string; age: number }>();
+  expectTypeOf(user).toExtend<{ name: string; age: number }>();
 
   const params = {
     page: 1,
@@ -32,5 +32,5 @@ test('sanitize', () => {
     limit: 10,
   });
 
-  expectTypeOf(query).toMatchTypeOf<{ page: number; limit: number }>();
+  expectTypeOf(query).toExtend<{ page: number; limit: number }>();
 });
diff --git a/modules/50-objects/35-mapping-modifiers/test.ts b/modules/50-objects/35-mapping-modifiers/test.ts
@@ -39,7 +39,7 @@ test('deepFreeze', () => {
     user.location.city = 'London';
   }).toThrow();
 
-  expectTypeOf(user).toMatchTypeOf<
+  expectTypeOf(user).toExtend<
     Readonly<{
       name: string;
       age: number;
diff --git a/modules/50-objects/45-record/test.ts b/modules/50-objects/45-record/test.ts
@@ -22,7 +22,7 @@ test('function', () => {
   const isUserAllowed = checkUserAccess('user', 'adminPanel');
   expect(isUserAllowed).toBe(false);
 
-  expectTypeOf(checkUserAccess).parameters.toMatchTypeOf<
+  expectTypeOf(checkUserAccess).parameters.toExtend<
     [UserRole, UserResource]
   >();
 });
