@depup/vitest__mocker 4.1.0-depup.0

package/dist/index.d-B41z0AuW.d.ts

@@ -0,0 +1,25 @@
+import './types.d-BjI5eAwu.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/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,200 @@
+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;
+			}
+			if (options.type === "autospy" && type === "Module") {
+				// Replace with clean object to recursively autospy exported module objects:
+				//   export * as ns from "./ns"
+				// or
+				//   import * as ns from "./ns"
+				//   export { ns }
+				const exports$1 = Object.create(null);
+				Object.defineProperty(exports$1, Symbol.toStringTag, {
+					value: "Module",
+					configurable: true,
+					writable: true
+				});
+				try {
+					newContainer[property] = exports$1;
+				} catch {
+					continue;
+				}
+			} else 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/mocker.d-QEntlm6J.d.ts

@@ -0,0 +1,86 @@
+import { MaybeMockedDeep } from '@vitest/spy';
+import { b as ModuleMockOptions, c as ModuleMockFactoryWithHelper, a as MockedModule, T as TestModuleMocker, M as MockerRegistry, d as MockedModuleType, e as ModuleMockContext } from './types.d-BjI5eAwu.js';
+import { C as CreateMockInstanceProcedure } from './index.d-B41z0AuW.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 implements TestModuleMocker {
+	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>;
+	protected getBaseUrl(): string;
+	importMock<T>(rawId: string, importer: string): Promise<T>;
+	mockObject(object: Record<string | symbol, any>, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	mockObject(object: Record<string | symbol, any>, mockExports: Record<string | symbol, any> | undefined, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	getMockContext(): ModuleMockContext;
+	queueMock(rawId: string, importer: string, factoryOrOptions?: ModuleMockOptions | (() => any)): void;
+	queueUnmock(id: string, importer: string): void;
+	wrapDynamicImport<T>(moduleFactory: () => Promise<T>): Promise<T>;
+	getMockedModuleById(id: string): MockedModule | undefined;
+	reset(): void;
+	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 f };
+export type { CompilerHintsOptions as C, ModuleMockerInterceptor as M, ResolveIdResult as R, ModuleMockerCompilerHints as a, ModuleMockerConfig as c, ModuleMockerRPC as d, ResolveMockResult as e };

package/dist/node.d.ts

@@ -0,0 +1,71 @@
+import { H as HoistMocksOptions } from './hoistMocks.d-w2ILr1dG.js';
+export { c as createManualModuleSource } from './hoistMocks.d-w2ILr1dG.js';
+import { AutomockOptions } from './automock.js';
+export { automockModule } from './automock.js';
+import { Plugin, Rollup, ViteDevServer } from 'vite';
+import { SourceMap } from 'magic-string';
+import { M as MockerRegistry, S as ServerMockResolution, f as ServerIdResolution } from './types.d-BjI5eAwu.js';
+export { findMockRedirect } from './redirect.js';
+
+declare function automockPlugin(options?: AutomockOptions): Plugin;
+
+interface DynamicImportPluginOptions {
+	/**
+	* @default `"__vitest_mocker__"`
+	*/
+	globalThisAccessor?: string;
+	filter?: (id: string) => boolean;
+}
+declare function dynamicImportPlugin(options?: DynamicImportPluginOptions): Plugin;
+
+interface HoistMocksPluginOptions extends Omit<HoistMocksOptions, "regexpHoistable"> {
+	include?: string | RegExp | (string | RegExp)[];
+	exclude?: string | RegExp | (string | RegExp)[];
+	/**
+	* overrides include/exclude options
+	*/
+	filter?: (id: string) => boolean;
+}
+declare function hoistMocksPlugin(options?: HoistMocksPluginOptions): Plugin;
+declare function hoistMockAndResolve(code: string, id: string, parse: Rollup.PluginContext["parse"], options?: HoistMocksOptions): HoistMocksResult | undefined;
+interface HoistMocksResult {
+	code: string;
+	map: SourceMap;
+}
+
+interface InterceptorPluginOptions {
+	/**
+	* @default "__vitest_mocker__"
+	*/
+	globalThisAccessor?: string;
+	registry?: MockerRegistry;
+}
+declare function interceptorPlugin(options?: InterceptorPluginOptions): Plugin;
+
+interface MockerPluginOptions extends AutomockOptions {
+	hoistMocks?: HoistMocksPluginOptions;
+}
+declare function mockerPlugin(options?: MockerPluginOptions): Plugin[];
+
+interface ServerResolverOptions {
+	/**
+	* @default ['/node_modules/']
+	*/
+	moduleDirectories?: string[];
+}
+declare class ServerMockResolver {
+	private server;
+	private options;
+	constructor(server: ViteDevServer, options?: ServerResolverOptions);
+	resolveMock(rawId: string, importer: string, options: {
+		mock: "spy" | "factory" | "auto";
+	}): Promise<ServerMockResolution>;
+	invalidate(ids: string[]): void;
+	resolveId(id: string, importer?: string): Promise<ServerIdResolution | null>;
+	private normalizeResolveIdToUrl;
+	private resolveMockId;
+	private resolveModule;
+}
+
+export { AutomockOptions as AutomockPluginOptions, ServerMockResolver, automockPlugin, dynamicImportPlugin, hoistMockAndResolve as hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin };
+export type { HoistMocksPluginOptions, HoistMocksResult, InterceptorPluginOptions, ServerResolverOptions };