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

package/dist/chunks/date.Bq6ZW5rf.js

@@ -0,0 +1,73 @@
+/* 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;
+}
+
+export { RealDate as R, mockDate as m, resetDate as r };

package/dist/chunks/defaults.BOqNVLsY.js

@@ -0,0 +1,74 @@
+import nodeos__default from 'node:os';
+import './env.D4Lgay0q.js';
+import { isCI } from '../vendor/std-env.mjs';
+
+const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+const defaultExclude = ["**/node_modules/**", "**/.git/**"];
+const benchmarkConfigDefaults = {
+  include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
+  exclude: defaultExclude,
+  includeSource: [],
+  reporters: ["default"],
+  includeSamples: false
+};
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
+const coverageConfigDefaults = {
+  provider: "v8",
+  enabled: false,
+  clean: true,
+  cleanOnRerun: true,
+  reportsDirectory: "./coverage",
+  exclude: [],
+  reportOnFailure: false,
+  reporter: [
+    ["text", {}],
+    ["html", {}],
+    ["clover", {}],
+    ["json", {}]
+  ],
+  allowExternal: false,
+  excludeAfterRemap: false,
+  processingConcurrency: Math.min(20, nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length)
+};
+const fakeTimersDefaults = {
+  loopLimit: 1e4,
+  shouldClearNativeTimers: true
+};
+const configDefaults = Object.freeze({
+  allowOnly: !isCI,
+  isolate: true,
+  watch: !isCI && process.stdin.isTTY,
+  globals: false,
+  environment: "node",
+  clearMocks: false,
+  restoreMocks: false,
+  mockReset: false,
+  unstubGlobals: false,
+  unstubEnvs: false,
+  include: defaultInclude,
+  exclude: defaultExclude,
+  teardownTimeout: 1e4,
+  forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+  update: false,
+  reporters: [],
+  silent: false,
+  hideSkippedTests: false,
+  api: false,
+  ui: false,
+  uiBase: "/__vitest__/",
+  open: !isCI,
+  css: { include: [] },
+  coverage: coverageConfigDefaults,
+  fakeTimers: fakeTimersDefaults,
+  maxConcurrency: 5,
+  dangerouslyIgnoreUnhandledErrors: false,
+  typecheck: {
+    checker: "tsc",
+    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
+    exclude: defaultExclude
+  },
+  slowTestThreshold: 300,
+  disableConsoleIntercept: false
+});
+
+export { coverageConfigDefaults as a, defaultInclude as b, configDefaults as c, defaultExclude as d, benchmarkConfigDefaults as e };

package/dist/chunks/env.D4Lgay0q.js

@@ -0,0 +1,8 @@
+import { isCI } from '../vendor/std-env.mjs';
+
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+const isWindows = (isNode || isDeno) && process.platform === "win32";
+const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
+
+export { isWindows as a, isTTY as i };

package/dist/chunks/environment.d.CrsxCzP1.d.ts

@@ -0,0 +1,29 @@
+import { Awaitable } from '../@vitest/utils/index.js';
+
+interface EnvironmentReturn {
+	teardown: (global: any) => Awaitable<void>;
+}
+interface VmEnvironmentReturn {
+	getVmContext: () => {
+		[key: string]: any;
+	};
+	teardown: () => Awaitable<void>;
+}
+interface Environment {
+	name: string;
+	/**
+	* @deprecated use `viteEnvironment` instead. Uses `name` by default
+	*/
+	transformMode?: "web" | "ssr";
+	/**
+	* Environment initiated by the Vite server. It is usually available
+	* as `vite.server.environments.${name}`.
+	*
+	* By default, fallbacks to `name`.
+	*/
+	viteEnvironment?: "client" | "ssr" | ({} & string);
+	setupVM?: (options: Record<string, any>) => Awaitable<VmEnvironmentReturn>;
+	setup: (global: any, options: Record<string, any>) => Awaitable<EnvironmentReturn>;
+}
+
+export type { Environment as E, VmEnvironmentReturn as V, EnvironmentReturn as a };

package/dist/chunks/evaluatedModules.Dg1zASAC.js

@@ -0,0 +1,17 @@
+import { dirname, resolve } from '../vendor/pathe.mjs';
+import { EvaluatedModules } from '@voidzero-dev/vite-plus-core/module-runner';
+
+// TODO: this is not needed in Vite 7.2+
+class VitestEvaluatedModules extends EvaluatedModules {
+  getModuleSourceMapById(id) {
+    const map = super.getModuleSourceMapById(id);
+    if (map != null && !("_patched" in map)) {
+      map._patched = true;
+      const dir = dirname(map.url);
+      map.resolvedSources = (map.map.sources || []).map((s) => resolve(dir, s || ""));
+    }
+    return map;
+  }
+}
+
+export { VitestEvaluatedModules as V };

package/dist/chunks/evaluatedModules.d.BxJ5omdx.d.ts

@@ -0,0 +1,7 @@
+import { EvaluatedModules } from '@voidzero-dev/vite-plus-core/module-runner';
+
+declare class VitestEvaluatedModules extends EvaluatedModules {
+	getModuleSourceMapById(id: string): any;
+}
+
+export { VitestEvaluatedModules as V };

package/dist/chunks/git.Bm2pzPAa.js

@@ -0,0 +1,71 @@
+import { resolve } from '../vendor/pathe.mjs';
+import { x } from '../vendor/tinyexec.mjs';
+
+class VitestGit {
+  root;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async resolveFilesWithGitCommand(args) {
+    let result;
+    try {
+      result = await x("git", args, { nodeOptions: { cwd: this.root } });
+    } catch (e) {
+      e.message = e.stderr;
+      throw e;
+    }
+    return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
+  }
+  async findChangedFiles(options) {
+    const root = await this.getRoot(this.cwd);
+    if (!root) return null;
+    this.root = root;
+    const changedSince = options.changedSince;
+    if (typeof changedSince === "string") {
+      const [committed, staged, unstaged] = await Promise.all([
+        this.getFilesSince(changedSince),
+        this.getStagedFiles(),
+        this.getUnstagedFiles()
+      ]);
+      return [
+        ...committed,
+        ...staged,
+        ...unstaged
+      ];
+    }
+    const [staged, unstaged] = await Promise.all([this.getStagedFiles(), this.getUnstagedFiles()]);
+    return [...staged, ...unstaged];
+  }
+  getFilesSince(hash) {
+    return this.resolveFilesWithGitCommand([
+      "diff",
+      "--name-only",
+      `${hash}...HEAD`
+    ]);
+  }
+  getStagedFiles() {
+    return this.resolveFilesWithGitCommand([
+      "diff",
+      "--cached",
+      "--name-only"
+    ]);
+  }
+  getUnstagedFiles() {
+    return this.resolveFilesWithGitCommand([
+      "ls-files",
+      "--other",
+      "--modified",
+      "--exclude-standard"
+    ]);
+  }
+  async getRoot(cwd) {
+    const args = ["rev-parse", "--show-cdup"];
+    try {
+      return resolve(cwd, (await x("git", args, { nodeOptions: { cwd } })).stdout.trim());
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { VitestGit };

package/dist/chunks/global.d.B15mdLcR.d.ts

@@ -0,0 +1,99 @@
+import { PromisifyAssertion, Tester, ExpectStatic } from '../@vitest/expect/index.js';
+import { Plugin } from '../@vitest/pretty-format/index.js';
+import { SnapshotState } from '../@vitest/snapshot/index.js';
+import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
+import { U as UserConsoleLog } from './rpc.d.RH3apGEf.js';
+
+interface SnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;
+	(hint?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, hint?: string): void;
+	(hint?: string): void;
+}
+declare module "../@vitest/expect/index.js" {
+	interface MatcherState {
+		environment: string;
+		snapshotState: SnapshotState;
+	}
+	interface ExpectPollOptions {
+		interval?: number;
+		timeout?: number;
+		message?: string;
+	}
+	interface ExpectStatic {
+		assert: Chai.AssertStatic;
+		unreachable: (message?: string) => never;
+		soft: <T>(actual: T, message?: string) => Assertion<T>;
+		poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+		addEqualityTesters: (testers: Array<Tester>) => void;
+		assertions: (expected: number) => void;
+		hasAssertions: () => void;
+		addSnapshotSerializer: (plugin: Plugin) => void;
+	}
+	interface Assertion<T> {
+		matchSnapshot: SnapshotMatcher<T>;
+		toMatchSnapshot: SnapshotMatcher<T>;
+		toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+		/**
+		* Checks that an error thrown by a function matches a previously recorded snapshot.
+		*
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* expect(functionWithError).toThrowErrorMatchingSnapshot();
+		*/
+		toThrowErrorMatchingSnapshot: (hint?: string) => void;
+		/**
+		* Checks that an error thrown by a function matches an inline snapshot within the test file.
+		* Useful for keeping snapshots close to the test code.
+		*
+		* @param snapshot - Optional inline snapshot string to match.
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* const throwError = () => { throw new Error('Error occurred') };
+		* expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+		*/
+		toThrowErrorMatchingInlineSnapshot: (snapshot?: string, hint?: string) => void;
+		/**
+		* Compares the received value to a snapshot saved in a specified file.
+		* Useful for cases where snapshot content is large or needs to be shared across tests.
+		*
+		* @param filepath - Path to the snapshot file.
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+		*/
+		toMatchFileSnapshot: (filepath: string, hint?: string) => Promise<void>;
+	}
+}
+declare module "../@vitest/runner/index.js" {
+	interface TestContext {
+		/**
+		* `expect` instance bound to the current test.
+		*
+		* This API is useful for running snapshot tests concurrently because global expect cannot track them.
+		*/
+		readonly expect: ExpectStatic;
+		/** @internal */
+		_local: boolean;
+	}
+	interface TaskMeta {
+		typecheck?: boolean;
+		benchmark?: boolean;
+		failScreenshotPath?: string;
+	}
+	interface File {
+		prepareDuration?: number;
+		environmentLoad?: number;
+	}
+	interface TaskBase {
+		logs?: UserConsoleLog[];
+	}
+	interface TaskResult {
+		benchmark?: BenchmarkResult;
+	}
+}

package/dist/chunks/globals.DOayXfHP.js

@@ -0,0 +1,30 @@
+import { g as globalApis } from './constants.D_Q9UYh-.js';
+import { i as index } from './index.Z5E_ObnR.js';
+import './vi.2VT5v0um.js';
+import '../@vitest/expect/index.js';
+import '../@vitest/runner/index.js';
+import './utils.DvEY5TfP.js';
+import '../@vitest/utils/timers.js';
+import '../@vitest/runner/utils.js';
+import '../@vitest/snapshot/index.js';
+import '../@vitest/utils/error.js';
+import '../@vitest/utils/helpers.js';
+import '../@vitest/spy/index.js';
+import '../@vitest/utils/offset.js';
+import '../@vitest/utils/source-map.js';
+import './_commonjsHelpers.D26ty3Ew.js';
+import './date.Bq6ZW5rf.js';
+import './benchmark.B3N2zMcH.js';
+import './evaluatedModules.Dg1zASAC.js';
+import '../vendor/pathe.mjs';
+import '@voidzero-dev/vite-plus-core/module-runner';
+import '../vendor/expect-type.mjs';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    // @ts-expect-error I know what I am doing :P
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/chunks/index.6Qv1eEA6.js

@@ -0,0 +1,109 @@
+import { chai } from '../@vitest/expect/index.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Cm-kSBVi.js';
+import { r as rpc } from './rpc.BoxB0q7B.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.B8ej_ZHS.js';
+
+function setupChaiConfig(config) {
+  Object.assign(chai.config, config);
+}
+
+async function resolveSnapshotEnvironment(config, executor) {
+  if (!config.snapshotEnvironment) {
+    const { VitestNodeSnapshotEnvironment } = await import('./node.Ce0vMQM7.js');
+    return new VitestNodeSnapshotEnvironment();
+  }
+  const mod = await executor.import(config.snapshotEnvironment);
+  if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
+  return mod.default;
+}
+
+async function getTestRunnerConstructor(config, moduleRunner) {
+  if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+  const mod = await moduleRunner.import(config.runner);
+  if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
+  return mod.default;
+}
+async function resolveTestRunner(config, moduleRunner, traces) {
+  const testRunner = new (await (getTestRunnerConstructor(config, moduleRunner)))(config);
+  // inject private executor to every runner
+  Object.defineProperty(testRunner, "moduleRunner", {
+    value: moduleRunner,
+    enumerable: false,
+    configurable: false
+  });
+  if (!testRunner.config) testRunner.config = config;
+  if (!testRunner.importFile) throw new Error("Runner must implement \"importFile\" method.");
+  if ("__setTraces" in testRunner) testRunner.__setTraces(traces);
+  const [diffOptions] = await Promise.all([loadDiffConfig(config, moduleRunner), loadSnapshotSerializers(config, moduleRunner)]);
+  testRunner.config.diffOptions = diffOptions;
+  // patch some methods, so custom runners don't need to call RPC
+  const originalOnTaskUpdate = testRunner.onTaskUpdate;
+  testRunner.onTaskUpdate = async (task, events) => {
+    const p = rpc().onTaskUpdate(task, events);
+    await originalOnTaskUpdate?.call(testRunner, task, events);
+    return p;
+  };
+  // patch some methods, so custom runners don't need to call RPC
+  const originalOnTestAnnotate = testRunner.onTestAnnotate;
+  testRunner.onTestAnnotate = async (test, annotation) => {
+    const p = rpc().onTaskArtifactRecord(test.id, {
+      type: "internal:annotation",
+      location: annotation.location,
+      annotation
+    });
+    const overriddenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation);
+    const vitestResult = await p;
+    return overriddenResult || vitestResult.annotation;
+  };
+  const originalOnTestArtifactRecord = testRunner.onTestArtifactRecord;
+  testRunner.onTestArtifactRecord = async (test, artifact) => {
+    const p = rpc().onTaskArtifactRecord(test.id, artifact);
+    const overriddenResult = await originalOnTestArtifactRecord?.call(testRunner, test, artifact);
+    const vitestResult = await p;
+    return overriddenResult || vitestResult;
+  };
+  const originalOnCollectStart = testRunner.onCollectStart;
+  testRunner.onCollectStart = async (file) => {
+    await rpc().onQueued(file);
+    await originalOnCollectStart?.call(testRunner, file);
+  };
+  const originalOnCollected = testRunner.onCollected;
+  testRunner.onCollected = async (files) => {
+    const state = getWorkerState();
+    files.forEach((file) => {
+      file.prepareDuration = state.durations.prepare;
+      file.environmentLoad = state.durations.environment;
+      // should be collected only for a single test file in a batch
+      state.durations.prepare = 0;
+      state.durations.environment = 0;
+    });
+    rpc().onCollected(files);
+    await originalOnCollected?.call(testRunner, files);
+  };
+  const originalOnAfterRun = testRunner.onAfterRunFiles;
+  testRunner.onAfterRunFiles = async (files) => {
+    const state = getWorkerState();
+    const coverage = await takeCoverageInsideWorker(config.coverage, moduleRunner);
+    if (coverage) rpc().onAfterSuiteRun({
+      coverage,
+      testFiles: files.map((file) => file.name).sort(),
+      environment: state.environment.viteEnvironment || state.environment.name,
+      projectName: state.ctx.projectName
+    });
+    await originalOnAfterRun?.call(testRunner, files);
+  };
+  const originalOnAfterRunTask = testRunner.onAfterRunTask;
+  testRunner.onAfterRunTask = async (test) => {
+    if (config.bail && test.result?.state === "fail") {
+      if (1 + await rpc().getCountOfFailedTests() >= config.bail) {
+        rpc().onCancel("test-failure");
+        testRunner.cancel?.("test-failure");
+      }
+    }
+    await originalOnAfterRunTask?.call(testRunner, test);
+  };
+  return testRunner;
+}
+
+export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };