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

package/dist/@vitest/mocker/chunk-registry.js

@@ -0,0 +1,185 @@
+class MockerRegistry {
+  registryByUrl = new Map();
+  registryById = new Map();
+  clear() {
+    this.registryByUrl.clear();
+    this.registryById.clear();
+  }
+  keys() {
+    return this.registryByUrl.keys();
+  }
+  add(mock) {
+    this.registryByUrl.set(mock.url, mock);
+    this.registryById.set(mock.id, mock);
+  }
+  register(typeOrEvent, raw, id, url, factoryOrRedirect) {
+    const type = typeof typeOrEvent === "object" ? typeOrEvent.type : typeOrEvent;
+    if (typeof typeOrEvent === "object") {
+      const event = typeOrEvent;
+      if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule) {
+        throw new TypeError(`[vitest] Cannot register a mock that is already defined. ` + `Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". ` + `Use "registry.add()" to update a mock instead.`);
+      }
+      if (event.type === "automock") {
+        const module = AutomockedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "autospy") {
+        const module = AutospiedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "redirect") {
+        const module = RedirectedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "manual") {
+        throw new Error(`Cannot set serialized manual mock. Define a factory function manually with \`ManualMockedModule.fromJSON()\`.`);
+      } else {
+        throw new Error(`Unknown mock type: ${event.type}`);
+      }
+    }
+    if (typeof raw !== "string") {
+      throw new TypeError("[vitest] Mocks require a raw string.");
+    }
+    if (typeof url !== "string") {
+      throw new TypeError("[vitest] Mocks require a url string.");
+    }
+    if (typeof id !== "string") {
+      throw new TypeError("[vitest] Mocks require an id string.");
+    }
+    if (type === "manual") {
+      if (typeof factoryOrRedirect !== "function") {
+        throw new TypeError("[vitest] Manual mocks require a factory function.");
+      }
+      const mock = new ManualMockedModule(raw, id, url, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else if (type === "automock" || type === "autospy") {
+      const mock = type === "automock" ? new AutomockedModule(raw, id, url) : new AutospiedModule(raw, id, url);
+      this.add(mock);
+      return mock;
+    } else if (type === "redirect") {
+      if (typeof factoryOrRedirect !== "string") {
+        throw new TypeError("[vitest] Redirect mocks require a redirect string.");
+      }
+      const mock = new RedirectedModule(raw, id, url, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else {
+      throw new Error(`[vitest] Unknown mock type: ${type}`);
+    }
+  }
+  delete(id) {
+    this.registryByUrl.delete(id);
+  }
+  deleteById(id) {
+    this.registryById.delete(id);
+  }
+  get(id) {
+    return this.registryByUrl.get(id);
+  }
+  getById(id) {
+    return this.registryById.get(id);
+  }
+  has(id) {
+    return this.registryByUrl.has(id);
+  }
+}
+class AutomockedModule {
+  type = "automock";
+  constructor(raw, id, url) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url;
+  }
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.id, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw,
+      id: this.id
+    };
+  }
+}
+class AutospiedModule {
+  type = "autospy";
+  constructor(raw, id, url) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url;
+  }
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.id, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      id: this.id,
+      raw: this.raw
+    };
+  }
+}
+class RedirectedModule {
+  type = "redirect";
+  constructor(raw, id, url, redirect) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url;
+    this.redirect = redirect;
+  }
+  static fromJSON(data) {
+    return new RedirectedModule(data.raw, data.id, data.url, data.redirect);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw,
+      id: this.id,
+      redirect: this.redirect
+    };
+  }
+}
+class ManualMockedModule {
+  cache;
+  type = "manual";
+  constructor(raw, id, url, factory) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url;
+    this.factory = factory;
+  }
+  async resolve() {
+    if (this.cache) {
+      return this.cache;
+    }
+    let exports$1;
+    try {
+      exports$1 = await this.factory();
+    } catch (err) {
+      const vitestError = new Error("[vitest] There was an error when mocking a module. " + "If you are using \"vi.mock\" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. " + "Read more: https://vitest.dev/api/vi.html#vi-mock");
+      vitestError.cause = err;
+      throw vitestError;
+    }
+    if (exports$1 === null || typeof exports$1 !== "object" || Array.isArray(exports$1)) {
+      throw new TypeError(`[vitest] vi.mock("${this.raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
+    }
+    return this.cache = exports$1;
+  }
+  static fromJSON(data, factory) {
+    return new ManualMockedModule(data.raw, data.id, data.url, factory);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      id: this.id,
+      raw: this.raw
+    };
+  }
+}
+
+export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, ManualMockedModule as a, AutospiedModule as b };

package/dist/@vitest/mocker/chunk-utils.js

@@ -0,0 +1,16 @@
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function createManualModuleSource(moduleUrl, exports$1, globalAccessor = "\"__vitest_mocker__\"") {
+  const source = `const module = globalThis[${globalAccessor}].getFactoryModule("${moduleUrl}");`;
+  const keys = exports$1.map((name) => {
+    if (name === "default") {
+      return `export default module["default"];`;
+    }
+    return `export const ${name} = module["${name}"];`;
+  }).join("\n");
+  return `${source}\n${keys}`;
+}
+
+export { cleanUrl as a, createManualModuleSource as c };

package/dist/@vitest/mocker/index.d-C-sLYZi-.d.ts

@@ -0,0 +1,25 @@
+import './types.d-B8CCKmHt.js';
+
+type Key = string | symbol;
+type CreateMockInstanceProcedure = (options?: {
+	prototypeMembers?: (string | symbol)[];
+	name?: string | symbol;
+	originalImplementation?: (...args: any[]) => any;
+	keepMembersImplementation?: boolean;
+}) => any;
+interface MockObjectOptions {
+	type: "automock" | "autospy";
+	globalConstructors: GlobalConstructors;
+	createMockInstance: CreateMockInstanceProcedure;
+}
+declare function mockObject(options: MockObjectOptions, object: Record<Key, any>, mockExports?: Record<Key, any>): Record<Key, any>;
+interface GlobalConstructors {
+	Object: ObjectConstructor;
+	Function: FunctionConstructor;
+	RegExp: RegExpConstructor;
+	Array: ArrayConstructor;
+	Map: MapConstructor;
+}
+
+export { mockObject as m };
+export type { CreateMockInstanceProcedure as C, GlobalConstructors as G, MockObjectOptions as M };

package/dist/@vitest/mocker/index.d.ts

@@ -0,0 +1,2 @@
+export { G as GlobalConstructors, M as MockObjectOptions, m as mockObject } from './index.d-C-sLYZi-.js';
+export { A as AutomockedModule, h as AutomockedModuleSerialized, f as AutospiedModule, i as AutospiedModuleSerialized, g as ManualMockedModule, j as ManualMockedModuleSerialized, a as MockedModule, k as MockedModuleSerialized, d as MockedModuleType, M as MockerRegistry, m as ModuleMockFactory, c as ModuleMockFactoryWithHelper, b as ModuleMockOptions, R as RedirectedModule, l as RedirectedModuleSerialized, e as ServerIdResolution, S as ServerMockResolution } from './types.d-B8CCKmHt.js';

package/dist/@vitest/mocker/index.js

@@ -0,0 +1,185 @@
+export { A as AutomockedModule, b as AutospiedModule, a as ManualMockedModule, M as MockerRegistry, R as RedirectedModule } from './chunk-registry.js';
+
+function mockObject(options, object, mockExports = {}) {
+  const finalizers = new Array();
+  const refs = new RefTracker();
+  const define = (container, key, value) => {
+    try {
+      container[key] = value;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const createMock = (currentValue) => {
+    if (!options.createMockInstance) {
+      throw new Error("[@vitest/mocker] `createMockInstance` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
+    }
+    const createMockInstance = options.createMockInstance;
+    const prototypeMembers = currentValue.prototype ? collectFunctionProperties(currentValue.prototype) : [];
+    return createMockInstance({
+      name: currentValue.name,
+      prototypeMembers,
+      originalImplementation: options.type === "autospy" ? currentValue : undefined,
+      keepMembersImplementation: options.type === "autospy"
+    });
+  };
+  const mockPropertiesOf = (container, newContainer) => {
+    const containerType = getType(container);
+    const isModule = containerType === "Module" || !!container.__esModule;
+    for (const { key: property, descriptor } of getAllMockableProperties(container, isModule, options.globalConstructors)) {
+      // Modules define their exports as getters. We want to process those.
+      if (!isModule && descriptor.get) {
+        try {
+          if (options.type === "autospy") {
+            Object.defineProperty(newContainer, property, descriptor);
+          } else {
+            Object.defineProperty(newContainer, property, {
+              configurable: descriptor.configurable,
+              enumerable: descriptor.enumerable,
+              get: () => {},
+              set: descriptor.set ? () => {} : undefined
+            });
+          }
+        } catch {}
+        continue;
+      }
+      // Skip special read-only props, we don't want to mess with those.
+      if (isReadonlyProp(container[property], property)) {
+        continue;
+      }
+      const value = container[property];
+      // Special handling of references we've seen before to prevent infinite
+      // recursion in circular objects.
+      const refId = refs.getId(value);
+      if (refId !== undefined) {
+        finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
+        continue;
+      }
+      const type = getType(value);
+      if (Array.isArray(value)) {
+        if (options.type === "automock") {
+          define(newContainer, property, []);
+        } else {
+          const array = value.map((value) => {
+            if (value && typeof value === "object") {
+              const newObject = {};
+              mockPropertiesOf(value, newObject);
+              return newObject;
+            }
+            if (typeof value === "function") {
+              return createMock(value);
+            }
+            return value;
+          });
+          define(newContainer, property, array);
+        }
+        continue;
+      }
+      const isFunction = type.includes("Function") && typeof value === "function";
+      if ((!isFunction || value._isMockFunction) && type !== "Object" && type !== "Module") {
+        define(newContainer, property, value);
+        continue;
+      }
+      // Sometimes this assignment fails for some unknown reason. If it does,
+      // just move along.
+      if (!define(newContainer, property, isFunction || options.type === "autospy" ? value : {})) {
+        continue;
+      }
+      if (isFunction) {
+        const mock = createMock(newContainer[property]);
+        newContainer[property] = mock;
+      }
+      refs.track(value, newContainer[property]);
+      mockPropertiesOf(value, newContainer[property]);
+    }
+  };
+  const mockedObject = mockExports;
+  mockPropertiesOf(object, mockedObject);
+  // Plug together refs
+  for (const finalizer of finalizers) {
+    finalizer();
+  }
+  return mockedObject;
+}
+class RefTracker {
+  idMap = new Map();
+  mockedValueMap = new Map();
+  getId(value) {
+    return this.idMap.get(value);
+  }
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
+  }
+  track(originalValue, mockedValue) {
+    const newId = this.idMap.size;
+    this.idMap.set(originalValue, newId);
+    this.mockedValueMap.set(newId, mockedValue);
+    return newId;
+  }
+}
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function isReadonlyProp(object, prop) {
+  if (prop === "arguments" || prop === "caller" || prop === "callee" || prop === "name" || prop === "length") {
+    const typeName = getType(object);
+    return typeName === "Function" || typeName === "AsyncFunction" || typeName === "GeneratorFunction" || typeName === "AsyncGeneratorFunction";
+  }
+  if (prop === "source" || prop === "global" || prop === "ignoreCase" || prop === "multiline") {
+    return getType(object) === "RegExp";
+  }
+  return false;
+}
+function getAllMockableProperties(obj, isModule, constructors) {
+  const { Map, Object, Function, RegExp, Array } = constructors;
+  const allProps = new Map();
+  let curr = obj;
+  do {
+    // we don't need properties from these
+    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype) {
+      break;
+    }
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(curr, key);
+      if (descriptor) {
+        allProps.set(key, {
+          key,
+          descriptor
+        });
+      }
+    });
+  } while (curr = Object.getPrototypeOf(curr));
+  // default is not specified in ownKeys, if module is interoped
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor) {
+      allProps.set("default", {
+        key: "default",
+        descriptor
+      });
+    }
+  }
+  return Array.from(allProps.values());
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function collectFunctionProperties(prototype) {
+  const properties = new Set();
+  collectOwnProperties(prototype, (prop) => {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, prop);
+    if (!descriptor || descriptor.get) {
+      return;
+    }
+    const type = getType(descriptor.value);
+    if (type.includes("Function") && !isReadonlyProp(descriptor.value, prop)) {
+      properties.add(prop);
+    }
+  });
+  return Array.from(properties);
+}
+
+export { mockObject };

package/dist/@vitest/mocker/mocker.d-TnKRhz7N.d.ts

@@ -0,0 +1,81 @@
+import { MaybeMockedDeep } from '../spy/index.js';
+import { b as ModuleMockOptions, c as ModuleMockFactoryWithHelper, a as MockedModule, M as MockerRegistry, d as MockedModuleType } from './types.d-B8CCKmHt.js';
+import { C as CreateMockInstanceProcedure } from './index.d-C-sLYZi-.js';
+
+interface CompilerHintsOptions {
+	/**
+	* This is the key used to access the globalThis object in the worker.
+	* Unlike `globalThisAccessor` in other APIs, this is not injected into the script.
+	* ```ts
+	* // globalThisKey: '__my_variable__' produces:
+	* globalThis['__my_variable__']
+	* // globalThisKey: '"__my_variable__"' produces:
+	* globalThis['"__my_variable__"'] // notice double quotes
+	* ```
+	* @default '__vitest_mocker__'
+	*/
+	globalThisKey?: string;
+}
+interface ModuleMockerCompilerHints {
+	hoisted: <T>(factory: () => T) => T;
+	mock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
+	unmock: (path: string | Promise<unknown>) => void;
+	doMock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
+	doUnmock: (path: string | Promise<unknown>) => void;
+	importActual: <T>(path: string) => Promise<T>;
+	importMock: <T>(path: string) => Promise<MaybeMockedDeep<T>>;
+}
+declare function createCompilerHints(options?: CompilerHintsOptions): ModuleMockerCompilerHints;
+
+interface ModuleMockerInterceptor {
+	register: (module: MockedModule) => Promise<void>;
+	delete: (url: string) => Promise<void>;
+	invalidate: () => Promise<void>;
+}
+
+declare class ModuleMocker {
+	private interceptor;
+	private rpc;
+	private createMockInstance;
+	private config;
+	protected registry: MockerRegistry;
+	private queue;
+	private mockedIds;
+	constructor(interceptor: ModuleMockerInterceptor, rpc: ModuleMockerRPC, createMockInstance: CreateMockInstanceProcedure, config: ModuleMockerConfig);
+	prepare(): Promise<void>;
+	resolveFactoryModule(id: string): Promise<Record<string | symbol, any>>;
+	getFactoryModule(id: string): any;
+	invalidate(): Promise<void>;
+	importActual<T>(id: string, importer: string): Promise<T>;
+	importMock<T>(rawId: string, importer: string): Promise<T>;
+	mockObject(object: Record<string | symbol, any>, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	queueMock(rawId: string, importer: string, factoryOrOptions?: ModuleMockOptions | (() => any)): void;
+	queueUnmock(id: string, importer: string): void;
+	wrapDynamicImport<T>(moduleFactory: () => Promise<T>): Promise<T>;
+	private resolveMockPath;
+}
+interface ResolveIdResult {
+	id: string;
+	url: string;
+	optimized: boolean;
+}
+interface ResolveMockResult {
+	mockType: MockedModuleType;
+	resolvedId: string;
+	resolvedUrl: string;
+	redirectUrl?: string | null;
+	needsInterop?: boolean;
+}
+interface ModuleMockerRPC {
+	invalidate: (ids: string[]) => Promise<void>;
+	resolveId: (id: string, importer: string) => Promise<ResolveIdResult | null>;
+	resolveMock: (id: string, importer: string, options: {
+		mock: "spy" | "factory" | "auto";
+	}) => Promise<ResolveMockResult>;
+}
+interface ModuleMockerConfig {
+	root: string;
+}
+
+export { ModuleMocker as b, createCompilerHints as c };
+export type { CompilerHintsOptions as C, ModuleMockerInterceptor as M, ResolveIdResult as R, ModuleMockerCompilerHints as a, ModuleMockerConfig as d, ModuleMockerRPC as e, ResolveMockResult as f };