@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/chunks/rpc.BoxB0q7B.js

@@ -0,0 +1,76 @@
+import { getSafeTimers } from '../@vitest/utils/timers.js';
+import { c as createBirpc } from './index.Chj8NDwU.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+
+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: [
+      "onUserConsoleLog",
+      "onCollected",
+      "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 { rpcDone as a, createRuntimeRpc as c, onCancel as o, rpc as r };

package/dist/chunks/rpc.d.RH3apGEf.d.ts

@@ -0,0 +1,64 @@
+import { CancelReason, File, TestArtifact, TaskResultPack, TaskEventPack } 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';
+
+interface AfterSuiteRunMeta {
+	coverage?: unknown;
+	testFiles: string[];
+	environment: string;
+	projectName?: string;
+}
+interface UserConsoleLog {
+	content: string;
+	origin?: string;
+	browser?: boolean;
+	type: "stdout" | "stderr";
+	taskId?: string;
+	time: number;
+	size: number;
+}
+interface ModuleGraphData {
+	graph: Record<string, string[]>;
+	externalized: string[];
+	inlined: string[];
+}
+interface ProvidedContext {}
+interface ResolveFunctionResult {
+	id: string;
+	file: string;
+	url: string;
+}
+interface FetchCachedFileSystemResult {
+	cached: true;
+	tmp: string;
+	id: string;
+	file: string | null;
+	url: string;
+	invalidate: boolean;
+}
+type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+
+interface RuntimeRPC {
+	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions, otelCarrier?: OTELCarrier) => Promise<FetchResult | FetchCachedFileSystemResult>;
+	resolve: (id: string, importer: string | undefined, environment: string) => Promise<ResolveFunctionResult | null>;
+	transform: (id: string) => Promise<{
+		code?: string;
+	}>;
+	onUserConsoleLog: (log: UserConsoleLog) => void;
+	onUnhandledError: (err: unknown, type: string) => void;
+	onQueued: (file: File) => void;
+	onCollected: (files: File[]) => Promise<void>;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskArtifactRecord: <Artifact extends TestArtifact>(testId: string, artifact: Artifact) => Promise<Artifact>;
+	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	onCancel: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	resolveSnapshotPath: (testPath: string) => string;
+}
+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 };

package/dist/chunks/setup-common.Cm-kSBVi.js

@@ -0,0 +1,60 @@
+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';
+
+async function startCoverageInsideWorker(options, loader, runtimeOptions) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) return coverageModule.startCoverage?.(runtimeOptions);
+  return null;
+}
+async function takeCoverageInsideWorker(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
+  return null;
+}
+async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) return coverageModule.stopCoverage?.(runtimeOptions);
+  return null;
+}
+
+let globalSetup = false;
+async function setupCommonEnv(config) {
+  setupDefines(config);
+  setupEnv(config.env);
+  if (globalSetup) return;
+  globalSetup = true;
+  setSafeTimers();
+  if (config.globals) (await import('./globals.DOayXfHP.js')).registerApiGlobally();
+}
+function setupDefines(config) {
+  for (const key in config.defines) globalThis[key] = config.defines[key];
+}
+function setupEnv(env) {
+  const state = getWorkerState();
+  // same boolean-to-string assignment as VitestPlugin.configResolved
+  const { PROD, DEV, ...restEnvs } = env;
+  state.metaEnv.PROD = PROD;
+  state.metaEnv.DEV = DEV;
+  for (const key in restEnvs) state.metaEnv[key] = env[key];
+}
+async function loadDiffConfig(config, moduleRunner) {
+  if (typeof config.diff === "object") return config.diff;
+  if (typeof config.diff !== "string") return;
+  const diffModule = await moduleRunner.import(config.diff);
+  if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) return diffModule.default;
+  else throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
+}
+async function loadSnapshotSerializers(config, moduleRunner) {
+  const files = config.snapshotSerializers;
+  (await Promise.all(files.map(async (file) => {
+    const mo = await moduleRunner.import(file);
+    if (!mo || typeof mo.default !== "object" || mo.default === null) throw new Error(`invalid snapshot serializer file ${file}. Must export a default object`);
+    const config = mo.default;
+    if (typeof config.test !== "function" || typeof config.serialize !== "function" && typeof config.print !== "function") throw new TypeError(`invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`);
+    return config;
+  }))).forEach((serializer) => addSerializer(serializer));
+}
+
+export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };