vitest 3.0.8 → 3.1.0-beta.1

package/dist/environments.d.ts

@@ -1,21 +1,21 @@
-import { E as Environment } from './chunks/environment.d8YfPkTm.js';
-export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d8YfPkTm.js';
+import { E as Environment } from './chunks/environment.d.C8UItCbf.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.C8UItCbf.js';
 
 declare const environments: {
-    'node': Environment;
-    'jsdom': Environment;
-    'happy-dom': Environment;
-    'edge-runtime': Environment;
+	"node": Environment
+	"jsdom": Environment
+	"happy-dom": Environment
+	"edge-runtime": Environment
 };
 
 interface PopulateOptions {
-    bindFunctions?: boolean;
-    additionalKeys?: string[];
+	bindFunctions?: boolean;
+	additionalKeys?: string[];
 }
 declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
-    keys: Set<string>;
-    skipKeys: string[];
-    originals: Map<string | symbol, any>;
+	keys: Set<string>
+	skipKeys: string[]
+	originals: Map<string | symbol, any>
 };
 
 export { Environment, environments as builtinEnvironments, populateGlobal };

package/dist/execute.d.ts

@@ -1,145 +1,145 @@
 import { ViteNodeRunnerOptions } from 'vite-node';
 import { ViteNodeRunner, ModuleExecutionInfo } from 'vite-node/client';
-import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.BmVno_ab.js';
+import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.d.C58isfFm.js';
 import vm from 'node:vm';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
-import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './chunks/mocker.cRtM890J.js';
+import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './chunks/mocker.d.BE_2ls6u.js';
 import '@vitest/runner';
-import './chunks/config.BCv-fVdT.js';
+import './chunks/config.d.DevWltVl.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import '@vitest/utils/diff';
-import './chunks/environment.d8YfPkTm.js';
+import './chunks/environment.d.C8UItCbf.js';
 
 declare class FileMap {
-    private fsCache;
-    private fsBufferCache;
-    readFileAsync(path: string): Promise<string>;
-    readFile(path: string): string;
-    readBuffer(path: string): Buffer;
+	private fsCache;
+	private fsBufferCache;
+	readFileAsync(path: string): Promise<string>;
+	readFile(path: string): string;
+	readBuffer(path: string): Buffer;
 }
 
 interface ModuleEvaluateOptions {
-    timeout?: vm.RunningScriptOptions['timeout'] | undefined;
-    breakOnSigint?: vm.RunningScriptOptions['breakOnSigint'] | undefined;
+	timeout?: vm.RunningScriptOptions["timeout"] | undefined;
+	breakOnSigint?: vm.RunningScriptOptions["breakOnSigint"] | undefined;
 }
 type ModuleLinker = (specifier: string, referencingModule: VMModule, extra: {
-    assert: object;
+	assert: object
 }) => VMModule | Promise<VMModule>;
-type ModuleStatus = 'unlinked' | 'linking' | 'linked' | 'evaluating' | 'evaluated' | 'errored';
+type ModuleStatus = "unlinked" | "linking" | "linked" | "evaluating" | "evaluated" | "errored";
 declare class VMModule {
-    dependencySpecifiers: readonly string[];
-    error: any;
-    identifier: string;
-    context: vm.Context;
-    namespace: object;
-    status: ModuleStatus;
-    evaluate(options?: ModuleEvaluateOptions): Promise<void>;
-    link(linker: ModuleLinker): Promise<void>;
+	dependencySpecifiers: readonly string[];
+	error: any;
+	identifier: string;
+	context: vm.Context;
+	namespace: object;
+	status: ModuleStatus;
+	evaluate(options?: ModuleEvaluateOptions): Promise<void>;
+	link(linker: ModuleLinker): Promise<void>;
 }
 
 interface ExternalModulesExecutorOptions {
-    context: vm.Context;
-    fileMap: FileMap;
-    packageCache: Map<string, any>;
-    transform: RuntimeRPC['transform'];
-    interopDefault?: boolean;
-    viteClientModule: Record<string, unknown>;
+	context: vm.Context;
+	fileMap: FileMap;
+	packageCache: Map<string, any>;
+	transform: RuntimeRPC["transform"];
+	interopDefault?: boolean;
+	viteClientModule: Record<string, unknown>;
 }
 declare class ExternalModulesExecutor {
-    #private;
-    private options;
-    private cjs;
-    private esm;
-    private vite;
-    private context;
-    private fs;
-    private resolvers;
-    constructor(options: ExternalModulesExecutorOptions);
-    import(identifier: string): Promise<object>;
-    require(identifier: string): any;
-    createRequire(identifier: string): NodeJS.Require;
-    importModuleDynamically: (specifier: string, referencer: VMModule) => Promise<VMModule>;
-    resolveModule: (specifier: string, referencer: string) => Promise<VMModule>;
-    resolve(specifier: string, parent: string): string;
-    private findNearestPackageData;
-    private wrapCoreSyntheticModule;
-    private wrapCommonJsSynteticModule;
-    private getModuleInformation;
-    private createModule;
-    private get isNetworkSupported();
+	#private;
+	private options;
+	private cjs;
+	private esm;
+	private vite;
+	private context;
+	private fs;
+	private resolvers;
+	constructor(options: ExternalModulesExecutorOptions);
+	import(identifier: string): Promise<object>;
+	require(identifier: string): any;
+	createRequire(identifier: string): NodeJS.Require;
+	importModuleDynamically: (specifier: string, referencer: VMModule) => Promise<VMModule>;
+	resolveModule: (specifier: string, referencer: string) => Promise<VMModule>;
+	resolve(specifier: string, parent: string): string;
+	private findNearestPackageData;
+	private wrapCoreSyntheticModule;
+	private wrapCommonJsSynteticModule;
+	private getModuleInformation;
+	private createModule;
+	private get isNetworkSupported();
 }
 
 interface MockContext {
-    /**
-     * When mocking with a factory, this refers to the module that imported the mock.
-     */
-    callstack: null | string[];
+	/**
+	* When mocking with a factory, this refers to the module that imported the mock.
+	*/
+	callstack: null | string[];
 }
 declare class VitestMocker {
-    executor: VitestExecutor;
-    static pendingIds: PendingSuiteMock[];
-    private spyModule?;
-    private primitives;
-    private filterPublicKeys;
-    private registries;
-    private mockContext;
-    constructor(executor: VitestExecutor);
-    private get root();
-    private get moduleCache();
-    private get moduleDirectories();
-    initializeSpyModule(): Promise<void>;
-    private getMockerRegistry;
-    reset(): void;
-    private deleteCachedItem;
-    private isModuleDirectory;
-    getSuiteFilepath(): string;
-    private createError;
-    private resolvePath;
-    resolveMocks(): Promise<void>;
-    private callFunctionMock;
-    getMockContext(): MockContext;
-    getMockPath(dep: string): string;
-    getDependencyMock(id: string): MockedModule | undefined;
-    normalizePath(path: string): string;
-    resolveMockPath(mockPath: string, external: string | null): string | null;
-    mockObject(object: Record<string | symbol, any>, mockExports?: Record<string | symbol, any>, behavior?: MockedModuleType): Record<string | symbol, any>;
-    unmockPath(path: string): void;
-    mockPath(originalId: string, path: string, external: string | null, mockType: MockedModuleType | undefined, factory: MockFactory | undefined): void;
-    importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
-    importMock(rawId: string, importee: string): Promise<any>;
-    requestWithMock(url: string, callstack: string[]): Promise<any>;
-    queueMock(id: string, importer: string, factoryOrOptions?: MockFactory | MockOptions): void;
-    queueUnmock(id: string, importer: string): void;
+	executor: VitestExecutor;
+	static pendingIds: PendingSuiteMock[];
+	private spyModule?;
+	private primitives;
+	private filterPublicKeys;
+	private registries;
+	private mockContext;
+	constructor(executor: VitestExecutor);
+	private get root();
+	private get moduleCache();
+	private get moduleDirectories();
+	initializeSpyModule(): Promise<void>;
+	private getMockerRegistry;
+	reset(): void;
+	private deleteCachedItem;
+	private isModuleDirectory;
+	getSuiteFilepath(): string;
+	private createError;
+	private resolvePath;
+	resolveMocks(): Promise<void>;
+	private callFunctionMock;
+	getMockContext(): MockContext;
+	getMockPath(dep: string): string;
+	getDependencyMock(id: string): MockedModule | undefined;
+	normalizePath(path: string): string;
+	resolveMockPath(mockPath: string, external: string | null): string | null;
+	mockObject(object: Record<string | symbol, any>, mockExports?: Record<string | symbol, any>, behavior?: MockedModuleType): Record<string | symbol, any>;
+	unmockPath(path: string): void;
+	mockPath(originalId: string, path: string, external: string | null, mockType: MockedModuleType | undefined, factory: MockFactory | undefined): void;
+	importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
+	importMock(rawId: string, importee: string): Promise<any>;
+	requestWithMock(url: string, callstack: string[]): Promise<any>;
+	queueMock(id: string, importer: string, factoryOrOptions?: MockFactory | MockOptions): void;
+	queueUnmock(id: string, importer: string): void;
 }
 
 interface ExecuteOptions extends ViteNodeRunnerOptions {
-    moduleDirectories?: string[];
-    state: WorkerGlobalState;
-    context?: vm.Context;
-    externalModulesExecutor?: ExternalModulesExecutor;
+	moduleDirectories?: string[];
+	state: WorkerGlobalState;
+	context?: vm.Context;
+	externalModulesExecutor?: ExternalModulesExecutor;
 }
 declare class VitestExecutor extends ViteNodeRunner {
-    options: ExecuteOptions;
-    mocker: VitestMocker;
-    externalModules?: ExternalModulesExecutor;
-    private primitives;
-    constructor(options: ExecuteOptions);
-    protected getContextPrimitives(): {
-        Object: typeof Object;
-        Reflect: typeof Reflect;
-        Symbol: typeof Symbol;
-    };
-    get state(): WorkerGlobalState;
-    get moduleExecutionInfo(): ModuleExecutionInfo | undefined;
-    shouldResolveId(id: string, _importee?: string | undefined): boolean;
-    originalResolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
-    resolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
-    protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
-    importExternalModule(path: string): Promise<any>;
-    dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
-    prepareContext(context: Record<string, any>): Record<string, any>;
+	options: ExecuteOptions;
+	mocker: VitestMocker;
+	externalModules?: ExternalModulesExecutor;
+	private primitives;
+	constructor(options: ExecuteOptions);
+	protected getContextPrimitives(): {
+		Object: typeof Object
+		Reflect: typeof Reflect
+		Symbol: typeof Symbol
+	};
+	get state(): WorkerGlobalState;
+	get moduleExecutionInfo(): ModuleExecutionInfo | undefined;
+	shouldResolveId(id: string, _importee?: string | undefined): boolean;
+	originalResolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
+	resolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
+	protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
+	importExternalModule(path: string): Promise<any>;
+	dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
+	prepareContext(context: Record<string, any>): Record<string, any>;
 }
 
 export { VitestExecutor };