feat(@schematics/angular): add matcher transformations to jasmine-to-vitest schematic

This commit adds transformers for a wide range of Jasmine matchers.

Coverage includes:
- Syntactic sugar matchers (toBeTrue, toHaveSize, etc.)
- Asymmetric matchers (jasmine.any, jasmine.objectContaining)
- Async matchers (expectAsync)
- Complex structural rewrites for matchers like 'toHaveBeenCalledOnceWith' and 'arrayWithExactContents'.

Author: clydin

packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer.ts

@@ -12,6 +12,18 @@ import {
   transformFocusedAndSkippedTests,
   transformPending,
 } from './transformers/jasmine-lifecycle';
+import {
+  transformArrayWithExactContents,
+  transformAsymmetricMatchers,
+  transformCalledOnceWith,
+  transformComplexMatchers,
+  transformExpectAsync,
+  transformExpectNothing,
+  transformSyntacticSugarMatchers,
+  transformToHaveClass,
+  transformWithContext,
+  transformtoHaveBeenCalledBefore,
+} from './transformers/jasmine-matcher';
 import { RefactorContext } from './utils/refactor-context';
 import { RefactorReporter } from './utils/refactor-reporter';
 
@@ -48,29 +60,55 @@ export function transformJasmineToVitest(
       // Transform the node itself based on its type
       if (ts.isCallExpression(transformedNode)) {
         const transformations = [
+          transformWithContext,
+          transformExpectAsync,
+          transformSyntacticSugarMatchers,
           transformFocusedAndSkippedTests,
+          transformComplexMatchers,
           transformPending,
           transformDoneCallback,
+          transformtoHaveBeenCalledBefore,
+          transformToHaveClass,
         ];
 
         for (const transformer of transformations) {
           transformedNode = transformer(transformedNode, refactorCtx);
         }
+      } else if (ts.isPropertyAccessExpression(transformedNode)) {
+        const transformations = [transformAsymmetricMatchers];
+
+        for (const transformer of transformations) {
+          transformedNode = transformer(transformedNode, refactorCtx);
+        }
+      } else if (ts.isExpressionStatement(transformedNode)) {
+        const statementTransformers = [
+          transformCalledOnceWith,
+          transformArrayWithExactContents,
+          transformExpectNothing,
+        ];
+
+        for (const transformer of statementTransformers) {
+          const result = transformer(transformedNode, refactorCtx);
+          if (result !== transformedNode) {
+            transformedNode = result;
+            break;
+          }
+        }
       }
 
       // Visit the children of the node to ensure they are transformed
       if (Array.isArray(transformedNode)) {
         return transformedNode.map((node) => ts.visitEachChild(node, visitor, context));
       } else {
-        return ts.visitEachChild(transformedNode, visitor, context);
+        return ts.visitEachChild(transformedNode as ts.Node, visitor, context);
       }
     };
 
     return (node) => ts.visitNode(node, visitor) as ts.SourceFile;
   };
 
   const result = ts.transform(sourceFile, [transformer]);
-  if (result.transformed[0] === sourceFile) {
+  if (result.transformed[0] === sourceFile && !reporter.hasTodos) {
     return content;
   }