@voidzero-dev/vite-plus-test 0.1.8 → 0.1.10

package/dist/chunks/rpc.MzXet3jl.js

@@ -0,0 +1,144 @@
+import { getSafeTimers } from '../@vitest/utils/timers.js';
+import { c as createBirpc } from './index.Chj8NDwU.js';
+import { g as getWorkerState } from './utils.BX5Fg8C4.js';
+
+/* Ported from https://github.com/boblauer/MockDate/blob/master/src/mockdate.ts */
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Bob Lauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+const RealDate = Date;
+let now = null;
+class MockDate extends RealDate {
+  constructor(y, m, d, h, M, s, ms) {
+    super();
+    let date;
+    switch (arguments.length) {
+      case 0:
+        if (now !== null) date = new RealDate(now.valueOf());
+        else date = new RealDate();
+        break;
+      case 1:
+        date = new RealDate(y);
+        break;
+      default:
+        d = typeof d === "undefined" ? 1 : d;
+        h = h || 0;
+        M = M || 0;
+        s = s || 0;
+        ms = ms || 0;
+        date = new RealDate(y, m, d, h, M, s, ms);
+        break;
+    }
+    Object.setPrototypeOf(date, MockDate.prototype);
+    return date;
+  }
+}
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+  return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+  return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+  return RealDate.toString();
+};
+function mockDate(date) {
+  const dateObj = new RealDate(date.valueOf());
+  if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+  // @ts-expect-error global
+  globalThis.Date = MockDate;
+  now = dateObj.valueOf();
+}
+function resetDate() {
+  globalThis.Date = RealDate;
+}
+
+const { get } = Reflect;
+function withSafeTimers(fn) {
+  const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentClearTimeout = globalThis.clearTimeout;
+  const currentSetImmediate = globalThis.setImmediate;
+  const currentClearImmediate = globalThis.clearImmediate;
+  const currentNextTick = globalThis.process?.nextTick;
+  try {
+    globalThis.setTimeout = setTimeout;
+    globalThis.clearTimeout = clearTimeout;
+    if (setImmediate) globalThis.setImmediate = setImmediate;
+    if (clearImmediate) globalThis.clearImmediate = clearImmediate;
+    if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
+    return fn();
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.clearTimeout = currentClearTimeout;
+    globalThis.setImmediate = currentSetImmediate;
+    globalThis.clearImmediate = currentClearImmediate;
+    if (globalThis.process && nextTick) nextTick(() => {
+      globalThis.process.nextTick = currentNextTick;
+    });
+  }
+}
+const promises = /* @__PURE__ */ new Set();
+async function rpcDone() {
+  if (!promises.size) return;
+  const awaitable = Array.from(promises);
+  return Promise.all(awaitable);
+}
+const onCancelCallbacks = [];
+function onCancel(callback) {
+  onCancelCallbacks.push(callback);
+}
+function createRuntimeRpc(options) {
+  return createSafeRpc(createBirpc({ async onCancel(reason) {
+    await Promise.all(onCancelCallbacks.map((fn) => fn(reason)));
+  } }, {
+    eventNames: ["onCancel"],
+    timeout: -1,
+    ...options
+  }));
+}
+function createSafeRpc(rpc) {
+  return new Proxy(rpc, { get(target, p, handler) {
+    // keep $rejectPendingCalls as sync function
+    if (p === "$rejectPendingCalls") return rpc.$rejectPendingCalls;
+    const sendCall = get(target, p, handler);
+    const safeSendCall = (...args) => withSafeTimers(async () => {
+      const result = sendCall(...args);
+      promises.add(result);
+      try {
+        return await result;
+      } finally {
+        promises.delete(result);
+      }
+    });
+    safeSendCall.asEvent = sendCall.asEvent;
+    return safeSendCall;
+  } });
+}
+function rpc() {
+  const { rpc } = getWorkerState();
+  return rpc;
+}
+
+export { RealDate as R, rpcDone as a, resetDate as b, createRuntimeRpc as c, mockDate as m, onCancel as o, rpc as r };

package/dist/chunks/{rpc.d.RH3apGEf.d.ts → rpc.d.BFMWpdph.d.ts}

@@ -1,4 +1,4 @@
-import { CancelReason, File, TestArtifact, TaskResultPack, TaskEventPack } from '../@vitest/runner/index.js';
+import { File, TestArtifact, TaskResultPack, TaskEventPack, CancelReason } from '../@vitest/runner/index.js';
 import { SnapshotResult } from '../@vitest/snapshot/index.js';
 import { FetchFunctionOptions, FetchResult } from '@voidzero-dev/vite-plus-core/module-runner';
 import { O as OTELCarrier } from './traces.d.402V_yFI.js';
@@ -38,6 +38,12 @@ interface FetchCachedFileSystemResult {
 	invalidate: boolean;
 }
 type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+interface AsyncLeak {
+	filename: string;
+	projectName: string;
+	stack: string;
+	type: string;
+}
 
 interface RuntimeRPC {
 	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions, otelCarrier?: OTELCarrier) => Promise<FetchResult | FetchCachedFileSystemResult>;
@@ -47,6 +53,7 @@ interface RuntimeRPC {
 	}>;
 	onUserConsoleLog: (log: UserConsoleLog) => void;
 	onUnhandledError: (err: unknown, type: string) => void;
+	onAsyncLeaks: (leak: AsyncLeak[]) => void;
 	onQueued: (file: File) => void;
 	onCollected: (files: File[]) => Promise<void>;
 	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
@@ -56,9 +63,10 @@ interface RuntimeRPC {
 	getCountOfFailedTests: () => number;
 	snapshotSaved: (snapshot: SnapshotResult) => void;
 	resolveSnapshotPath: (testPath: string) => string;
+	ensureModuleGraphEntry: (id: string, importer: string) => void;
 }
 interface RunnerRPC {
 	onCancel: (reason: CancelReason) => void;
 }
 
-export type { AfterSuiteRunMeta as A, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, UserConsoleLog as U, RunnerRPC as a };
+export type { AfterSuiteRunMeta as A, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, UserConsoleLog as U, RunnerRPC as a, AsyncLeak as b };

package/dist/chunks/{setup-common.Cm-kSBVi.js → setup-common.B41N_kPE.js}

@@ -1,7 +1,7 @@
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '../@vitest/snapshot/index.js';
 import { setSafeTimers } from '../@vitest/utils/timers.js';
-import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import { g as getWorkerState } from './utils.BX5Fg8C4.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
   const coverageModule = await resolveCoverageProviderModule(options, loader);
@@ -26,7 +26,7 @@ async function setupCommonEnv(config) {
   if (globalSetup) return;
   globalSetup = true;
   setSafeTimers();
-  if (config.globals) (await import('./globals.DOayXfHP.js')).registerApiGlobally();
+  if (config.globals) (await import('./globals.BXNGLnTL.js')).registerApiGlobally();
 }
 function setupDefines(config) {
   for (const key in config.defines) globalThis[key] = config.defines[key];
@@ -57,4 +57,4 @@ async function loadSnapshotSerializers(config, moduleRunner) {
   }))).forEach((serializer) => addSerializer(serializer));
 }
 
-export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };
+export { loadSnapshotSerializers as a, startCoverageInsideWorker as b, stopCoverageInsideWorker as c, loadDiffConfig as l, setupCommonEnv as s, takeCoverageInsideWorker as t };