feat(zone.js): support vitest patching in zone.js/testing

To support `fakeAsync` usage while using `vitest` as a test runner, Zone.js
now provides patching when using the `zone.js/testing` package import.
This patching is similar to that of the existing jasmine, mocha, and jest
functionality.

Author: clydin

packages/zone.js/lib/testing/zone-testing.ts

@@ -9,6 +9,7 @@
 import {patchJasmine} from '../jasmine/jasmine';
 import {patchJest} from '../jest/jest';
 import {patchMocha} from '../mocha/mocha';
+import {patchVitest} from '../vitest/vitest';
 import {ZoneType} from '../zone-impl';
 import {patchAsyncTest} from '../zone-spec/async-test';
 import {patchFakeAsyncTest} from '../zone-spec/fake-async-test';
@@ -25,6 +26,7 @@ export function rollupTesting(Zone: ZoneType): void {
   patchJasmine(Zone);
   patchJest(Zone);
   patchMocha(Zone);
+  patchVitest(Zone);
   patchAsyncTest(Zone);
   patchFakeAsyncTest(Zone);
   patchPromiseTesting(Zone);

packages/zone.js/lib/vitest/vitest.ts

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import {ZoneType} from '../zone-impl';
+
+declare let vitest: any;
+
+export function patchVitest(Zone: ZoneType): void {
+  Zone.__load_patch('vitest', (context: any, Zone: ZoneType, api: _ZonePrivate) => {
+    if (typeof vitest === 'undefined' || vitest['__zone_patch__']) {
+      return;
+    }
+
+    vitest['__zone_patch__'] = true;
+
+    const ProxyZoneSpec = (Zone as any)['ProxyZoneSpec'];
+    const SyncTestZoneSpec = (Zone as any)['SyncTestZoneSpec'];
+
+    if (!ProxyZoneSpec) {
+      throw new Error('Missing ProxyZoneSpec');
+    }
+
+    const rootZone = Zone.current;
+    const syncZone = rootZone.fork(new SyncTestZoneSpec('vitest.describe'));
+    const proxyZoneSpec = new ProxyZoneSpec();
+    const proxyZone = rootZone.fork(proxyZoneSpec);
+
+    function wrapDescribeFactoryInZone(originalVitestFn: Function) {
+      return function (this: unknown, ...describeArgs: any[]) {
+        const originalDescribeFn = originalVitestFn.apply(this, describeArgs);
+        return function (this: unknown, ...args: any[]) {
+          args[1] = wrapDescribeInZone(args[1]);
+          return originalDescribeFn.apply(this, args);
+        };
+      };
+    }
+
+    function wrapTestFactoryInZone(originalVitestFn: Function) {
+      return function (this: unknown, ...testArgs: any[]) {
+        return function (this: unknown, ...args: any[]) {
+          args[1] = wrapTestInZone(args[1]);
+          return originalVitestFn.apply(this, testArgs).apply(this, args);
+        };
+      };
+    }
+
+    /**
+     * Gets a function wrapping the body of a vitest `describe` block to execute in a
+     * synchronous-only zone.
+     */
+    function wrapDescribeInZone(describeBody: Function): Function {
+      return function (this: unknown, ...args: any[]) {
+        return syncZone.run(describeBody, this, args);
+      };
+    }
+
+    /**
+     * Gets a function wrapping the body of a vitest `it/beforeEach/afterEach` block to
+     * execute in a ProxyZone zone.
+     * This will run in the `proxyZone`.
+     */
+    function wrapTestInZone(testBody: Function, isTestFunc = false): Function {
+      if (typeof testBody !== 'function') {
+        return testBody;
+      }
+      const wrappedFunc = function () {
+        proxyZoneSpec.isTestFunc = isTestFunc;
+        return proxyZone.run(testBody, null, arguments as any);
+      };
+      // Update the length of wrappedFunc to be the same as the length of the testBody
+      // So vitest core can handle whether the test function has `done()` or not correctly
+      Object.defineProperty(wrappedFunc, 'length', {
+        configurable: true,
+        writable: true,
+        enumerable: false,
+      });
+      wrappedFunc.length = testBody.length;
+      return wrappedFunc;
+    }
+
+    ['suite', 'describe'].forEach((methodName) => {
+      let originalVitestFn: Function = context[methodName];
+      if (context[Zone.__symbol__(methodName)]) {
+        return;
+      }
+
+      context[Zone.__symbol__(methodName)] = originalVitestFn;
+      context[methodName] = function (this: unknown, ...args: any[]) {
+        args[1] = wrapDescribeInZone(args[1]);
+        return originalVitestFn.apply(this, args);
+      };
+
+      [
+        'skip',
+        'skipIf',
+        'runIf',
+        'only',
+        'concurrent',
+        'sequential',
+        'shuffle',
+        'todo',
+        'each',
+        'for',
+      ].forEach((subMethodName) => {
+        context[methodName][subMethodName] = wrapDescribeFactoryInZone(
+          (originalVitestFn as any)[subMethodName],
+        );
+      });
+    });
+
+    ['it', 'test'].forEach((methodName) => {
+      let originalVitestFn: Function = context[methodName];
+      if (context[Zone.__symbol__(methodName)]) {
+        return;
+      }
+
+      context[Zone.__symbol__(methodName)] = originalVitestFn;
+      context[methodName] = function (this: unknown, ...args: any[]) {
+        args[1] = wrapTestInZone(args[1], true);
+        return originalVitestFn.apply(this, args);
+      };
+
+      [
+        'skip',
+        'skipIf',
+        'runIf',
+        'only',
+        'concurrent',
+        'sequential',
+        'todo',
+        'fails',
+        'each',
+        'for',
+      ].forEach((subMethodName) => {
+        context[methodName][subMethodName] = wrapTestFactoryInZone(
+          (originalVitestFn as any)[subMethodName],
+        );
+      });
+    });
+
+    ['beforeEach', 'afterEach', 'beforeAll', 'afterAll'].forEach((methodName) => {
+      const originalVitestFn: Function = context[methodName];
+      if (context[Zone.__symbol__(methodName)]) {
+        return;
+      }
+
+      context[Zone.__symbol__(methodName)] = originalVitestFn;
+      context[methodName] = function (this: unknown, ...args: any[]) {
+        args[0] = wrapTestInZone(args[0]);
+        return originalVitestFn.apply(this, args);
+      };
+    });
+  });
+}