@untestutils/nuxt 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 s00d
+
+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.

package/dist/config/index.d.mts

@@ -0,0 +1,58 @@
+import type { Nuxt, NuxtConfig, ViteConfig as NuxtViteConfig } from "@nuxt/schema";
+import type { DotenvOptions } from "c12";
+import type { InlineConfig as VitestConfig } from "vitest/node";
+import type { Plugin, UserConfig as ViteUserConfig } from "vite";
+type NitroRef = {
+	current?: {
+		hooks: {
+			callHook: (name: "close") => Promise<void>;
+		};
+	};
+};
+type LoadedNuxtViteConfig = {
+	nuxt: Nuxt;
+	viteConfig: NuxtViteConfig;
+	nitro?: NitroRef;
+};
+type StartNuxtOptions = {
+	dotenv?: Partial<DotenvOptions>;
+	nitroEnvironment?: boolean;
+	overrides?: Partial<NuxtConfig>;
+};
+type ResolvedVitestConfig = ViteUserConfig & {
+	extends?: false;
+	test: VitestConfig;
+	plugins: Plugin[];
+	optimizeDeps?: {
+		noDiscovery?: boolean;
+		include?: string[];
+	};
+	define?: Record<string, unknown>;
+	ssr?: {
+		resolve?: {
+			conditions?: string[];
+		};
+	};
+	customLogger?: unknown;
+};
+export interface NuxtConfigOptions {
+	rootDir?: string;
+	domEnvironment?: "happy-dom" | "jsdom";
+	overrides?: Partial<NuxtConfig>;
+	dotenv?: Partial<DotenvOptions>;
+	nitroEnvironment?: boolean;
+	[key: string]: unknown;
+}
+export interface DefineVitestConfigInput extends ViteUserConfig {
+	test?: VitestConfig & {
+		environment?: string;
+		environmentOptions?: {
+			nuxt?: NuxtConfigOptions;
+			[key: string]: unknown;
+		};
+	};
+}
+export declare function getVitestConfigFromNuxt(options?: LoadedNuxtViteConfig, loadNuxtOptions?: StartNuxtOptions): Promise<ResolvedVitestConfig>;
+export declare function defineVitestProject(config?: DefineVitestConfigInput): Promise<ResolvedVitestConfig>;
+export declare function defineVitestConfig(config?: DefineVitestConfigInput): () => Promise<ResolvedVitestConfig>;
+export {};

package/dist/config/index.d.ts

@@ -0,0 +1,59 @@
+import type { Nuxt, NuxtConfig, ViteConfig as NuxtViteConfig } from '@nuxt/schema';
+import type { DotenvOptions } from 'c12';
+import type { InlineConfig as VitestConfig } from 'vitest/node';
+import type { Plugin, UserConfig as ViteUserConfig } from 'vite';
+type NitroRef = {
+    current?: {
+        hooks: {
+            callHook: (name: 'close') => Promise<void>;
+        };
+    };
+};
+type LoadedNuxtViteConfig = {
+    nuxt: Nuxt;
+    viteConfig: NuxtViteConfig;
+    nitro?: NitroRef;
+};
+type StartNuxtOptions = {
+    dotenv?: Partial<DotenvOptions>;
+    nitroEnvironment?: boolean;
+    overrides?: Partial<NuxtConfig>;
+};
+type ResolvedVitestConfig = ViteUserConfig & {
+    extends?: false;
+    test: VitestConfig;
+    plugins: Plugin[];
+    optimizeDeps?: {
+        noDiscovery?: boolean;
+        include?: string[];
+    };
+    define?: Record<string, unknown>;
+    ssr?: {
+        resolve?: {
+            conditions?: string[];
+        };
+    };
+    customLogger?: unknown;
+};
+export interface NuxtConfigOptions {
+    rootDir?: string;
+    domEnvironment?: 'happy-dom' | 'jsdom';
+    overrides?: Partial<NuxtConfig>;
+    dotenv?: Partial<DotenvOptions>;
+    nitroEnvironment?: boolean;
+    [key: string]: unknown;
+}
+export interface DefineVitestConfigInput extends ViteUserConfig {
+    test?: VitestConfig & {
+        environment?: string;
+        environmentOptions?: {
+            nuxt?: NuxtConfigOptions;
+            [key: string]: unknown;
+        };
+    };
+}
+export declare function getVitestConfigFromNuxt(options?: LoadedNuxtViteConfig, loadNuxtOptions?: StartNuxtOptions): Promise<ResolvedVitestConfig>;
+export declare function defineVitestProject(config?: DefineVitestConfigInput): Promise<ResolvedVitestConfig>;
+export declare function defineVitestConfig(config?: DefineVitestConfigInput): () => Promise<ResolvedVitestConfig>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,IAAI,YAAY,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,IAAI,cAAc,EAAkB,MAAM,MAAM,CAAC;AAWjF,KAAK,QAAQ,GAAG;IAAE,OAAO,CAAC,EAAE;QAAE,KAAK,EAAE;YAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,CAAC;AACxF,KAAK,oBAAoB,GAAG;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,cAAc,CAAC;IAC3B,KAAK,CAAC,EAAE,QAAQ,CAAC;CAClB,CAAC;AACF,KAAK,gBAAgB,GAAG;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;CACjC,CAAC;AACF,KAAK,oBAAoB,GAAG,cAAc,GAAG;IAC3C,OAAO,CAAC,EAAE,KAAK,CAAC;IAChB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,GAAG,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE;YAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAA;KAAE,CAAC;IAC9C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AA6GF,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;IACvC,SAAS,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,uBAAwB,SAAQ,cAAc;IAC7D,IAAI,CAAC,EAAE,YAAY,GAAG;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,kBAAkB,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,iBAAiB,CAAC;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;KAC3E,CAAC;CACH;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,CAAC,EAAE,oBAAoB,EAC9B,eAAe,GAAE,gBAAqB,GACrC,OAAO,CAAC,oBAAoB,CAAC,CAuJ/B;AAKD,wBAAsB,mBAAmB,CAAC,MAAM,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAKzG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,uBAA4B,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAqE5G"}

package/dist/config/index.mjs

@@ -0,0 +1,323 @@
+
+import { deepCopy, loadKit, applyEnv } from "./utils.mjs";
+import { createDefu, defu } from "defu";
+import { resolveModulePath } from "exsolve";
+import process from "node:process";
+import { version } from "vitest/node";
+import { setupDotenv } from "c12";
+import { getPackageInfoSync } from "local-pkg";
+import { fileURLToPath } from "node:url";
+
+function runtimeFile(rel) {
+	return fileURLToPath(new URL(`../runtime/${rel}.mjs`, import.meta.url));
+}
+function isUnitEnvironmentName(env) {
+	return env === "untestutils" || env === "nuxt";
+}
+function isNamedPlugin(plugin) {
+	return typeof plugin === "object" && plugin !== null && "name" in plugin;
+}
+function warnIfE2ePluginMixed(config) {
+	const plugins = config.plugins || [];
+	const hasE2e = plugins.some((p) => isNamedPlugin(p) && p.name === "untestutils");
+	const env = config.test?.environment;
+	if (hasE2e && isUnitEnvironmentName(env)) {
+		console.warn("[untestutils] Do not mix `untestutils/vitest/plugin` (e2e) with `environment: 'untestutils'` (unit). Use separate projects.");
+	}
+}
+const PLUGIN_NAME = "untestutils:vitest:environment-options";
+const STUB_ID = "untestutils-vitest-environment-options";
+function NuxtVitestEnvironmentOptionsPlugin(environmentOptions = {}) {
+	return {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		resolveId(id) {
+			if (id.endsWith(STUB_ID)) return STUB_ID;
+		},
+		load(id) {
+			if (id.endsWith(STUB_ID)) return `export default ${JSON.stringify(environmentOptions || {})}`;
+		}
+	};
+}
+const DISABLE_NITRO_ENVIRONMENT = { experimental: { nitroViteEnvironment: false } };
+async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {}) {
+	const { buildNuxt, loadNuxt } = await loadKit(rootDir);
+	const nuxt = await loadNuxt({
+		cwd: rootDir,
+		dev: options.nitroEnvironment || (options.overrides?.dev ?? false),
+		dotenv: defu(options.dotenv, {
+			cwd: rootDir,
+			fileName: ".env.test"
+		}),
+		defaults: { compatibilityDate: "2024-04-03" },
+		overrides: defu({
+			appId: "nuxt-app",
+			buildId: "test",
+			ssr: false,
+			test: true,
+			modules: ["@untestutils/nuxt/module"],
+			experimental: { appManifest: false }
+		}, options.overrides, options.nitroEnvironment ? {} : DISABLE_NITRO_ENVIRONMENT)
+	});
+	if (!nuxt.options._installedModules.find((i) => i?.meta?.name === "untestutils")) throw new Error("Failed to load `@untestutils/nuxt/module`. Add it to your nuxt.config modules.");
+	const nitro = options.nitroEnvironment ? {} : undefined;
+	if (nitro) nuxt.hook("nitro:init", (instance) => {
+		nitro.current = instance;
+	});
+	return new Promise((resolve, reject) => {
+		nuxt.hook("vite:configResolved", (viteConfig, { isClient }) => {
+			if (isClient) {
+				resolve({
+					nuxt,
+					viteConfig,
+					nitro
+				});
+				throw new Error("_stop_");
+			}
+		});
+		buildNuxt(nuxt).catch((err) => {
+			if (!String(err).includes("_stop_")) reject(err);
+		});
+	}).finally(() => nuxt.close());
+}
+function nitroTeardownPlugin(nitro) {
+	let closed;
+	return {
+		name: "untestutils:nitro-teardown",
+		async closeBundle() {
+			closed ||= nitro.current?.hooks.callHook("close") ?? Promise.resolve();
+			await closed;
+		}
+	};
+}
+const excludedPlugins = [
+	"nuxt:import-protection",
+	"nuxt:import-conditions",
+	"nuxt:devtools:rpc",
+	"nuxt:devtools:config-retriever",
+	"vite-plugin-checker",
+	"vite-plugin-inspect",
+	"vite-plugin-vue-tracer"
+];
+export async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
+	const { rootDir: rawRootDir = process.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
+	const rootDir = typeof rawRootDir === "string" ? rawRootDir : process.cwd();
+	if (!options) options = await startNuxtAndGetViteConfig(rootDir, {
+		dotenv: loadNuxtOptions.dotenv,
+		nitroEnvironment: loadNuxtOptions.nitroEnvironment,
+		overrides: {
+			test: true,
+			..._overrides
+		}
+	});
+	const viteConfig = {
+		...options.viteConfig,
+		root: undefined,
+		plugins: [...options.viteConfig.plugins || []].filter((p) => !isNamedPlugin(p) || !excludedPlugins.includes(p.name))
+	};
+	const nuxtServerIntegration = getPackageInfoSync("@nuxt/nitro-server", { paths: [options.nuxt.options.appDir] });
+	let nitroPath;
+	for (const nitroCandidate of [...nuxtServerIntegration?.packageJson.dependencies?.nitro ? ["nitro", "nitro-nightly"] : ["nitropack", "nitropack-nightly"]]) {
+		nitroPath = resolveModulePath(nitroCandidate, {
+			from: nuxtServerIntegration?.rootPath || options.nuxt.options.appDir,
+			try: true
+		});
+		if (nitroPath) break;
+	}
+	const projectH3Path = resolveModulePath("h3/package.json", {
+		from: rootDir,
+		try: true
+	});
+	const h3Info = (projectH3Path ? getPackageInfoSync("h3", { paths: [projectH3Path] }) : undefined) || getPackageInfoSync("h3", { paths: nitroPath ? [nitroPath] : options.nuxt.options.modulesDir });
+	const routeRules = "routeRules" in options.nuxt.options && isObjectRecord(options.nuxt.options.routeRules) ? options.nuxt.options.routeRules : undefined;
+	const nitroOptions = "nitro" in options.nuxt.options && isObjectRecord(options.nuxt.options.nitro) ? options.nuxt.options.nitro : undefined;
+	const resolvedConfig = defu({
+		define: {
+			"process.env.NODE_ENV": "\"test\"",
+			__NUXT_VITEST_RESOLVED__: "true"
+		},
+		resolve: { alias: {
+			"@vue/devtools-kit": runtimeFile("mocks/vue-devtools"),
+			"@vue/devtools-core": runtimeFile("mocks/vue-devtools")
+		} },
+		optimizeDeps: { noDiscovery: true },
+		test: {
+			environmentOptions: {
+				nuxtRuntimeConfig: applyEnv(deepCopy(options.nuxt.options.runtimeConfig), {
+					prefix: "NUXT_",
+					env: await setupDotenv(defu(loadNuxtOptions.dotenv, {
+						cwd: rootDir,
+						fileName: ".env.test"
+					}))
+				}),
+				nuxtRouteRules: defu({}, routeRules, isObjectRecord(nitroOptions?.routeRules) ? nitroOptions.routeRules : undefined),
+				nuxtAppConfig: {
+					rootAttrs: options.nuxt.options.app.rootAttrs,
+					rootTag: options.nuxt.options.app.rootTag,
+					teleportAttrs: options.nuxt.options.app.teleportAttrs,
+					teleportTag: options.nuxt.options.app.teleportTag
+				}
+			},
+			server: { deps: { inline: [
+				/\/node_modules\/(.*\/)?(nuxt|nuxt3|nuxt-nightly)\//,
+				/^#/,
+				"untestutils",
+				"@untestutils/nuxt",
+				"vitest-environment-untestutils",
+				...options.nuxt.options.build.transpile.filter((r) => typeof r === "string" || r instanceof RegExp)
+			] } },
+			deps: { optimizer: { client: { enabled: false } } }
+		}
+	}, {
+		server: { middlewareMode: false },
+		plugins: [
+			{
+				name: "disable-auto-execute",
+				enforce: "pre",
+				transform(code, id) {
+					if (id.match(/nuxt(3|-nightly)?\/.*\/entry\./)) return code.replace(/(?<!vueAppPromise = )entry\(\)/, "Promise.resolve()");
+				}
+			},
+			...options.nitro ? [nitroTeardownPlugin(options.nitro)] : [],
+			{
+				name: "untestutils:browser-conditions",
+				enforce: "pre",
+				config() {
+					return { resolve: { conditions: [
+						"web",
+						"import",
+						"module",
+						"default"
+					] } };
+				},
+				configResolved(config) {
+					if (config.ssr.resolve?.conditions) config.ssr.resolve.conditions = config.ssr.resolve.conditions.filter((x) => x !== "import");
+				}
+			}
+		]
+	}, viteConfig, { test: { environmentOptions: { nuxt: {
+		rootId: options.nuxt.options.app.rootAttrs?.id || undefined,
+		h3Version: h3Info?.version?.startsWith("2.") ? 2 : 1,
+		mock: {
+			intersectionObserver: true,
+			indexedDb: false
+		}
+	} } } });
+	resolvedConfig.define ??= {};
+	delete resolvedConfig.define["process.browser"];
+	delete resolvedConfig.customLogger;
+	delete resolvedConfig.ssr;
+	resolvedConfig.test.setupFiles = normalizeSetupFiles(resolvedConfig.test.setupFiles);
+	resolvedConfig.test.setupFiles.unshift(runtimeFile("entry"));
+	return resolvedConfig;
+}
+const vitestMajor = Number(version.split(".")[0]);
+const UNIT_ENVIRONMENT = "untestutils";
+export async function defineVitestProject(config) {
+	const resolvedConfig = await resolveConfig(defu({ test: { environment: UNIT_ENVIRONMENT } }, config));
+	resolvedConfig.extends ??= false;
+	warnIfE2ePluginMixed(resolvedConfig);
+	return resolvedConfig;
+}
+export function defineVitestConfig(config = {}) {
+	return async () => {
+		const resolvedConfig = await resolveConfig(config);
+		if (resolvedConfig.test.browser?.enabled) return resolvedConfig;
+		if ("workspace" in resolvedConfig.test || "projects" in resolvedConfig.test) throw new Error("The `projects` option is not supported with `defineVitestConfig`. Use `defineVitestProject` per project.");
+		const defaultEnvironment = resolvedConfig.test.environment || "node";
+		const isUnitEnv = isUnitEnvironmentName(defaultEnvironment);
+		if (!isUnitEnv) {
+			const merge = createDefu((obj, key, value) => {
+				if (Array.isArray(value) && Array.isArray(obj[key])) {
+					const target = obj;
+					const stringKey = String(key);
+					target[stringKey] = [...new Set([...value, ...target[stringKey]])];
+					return true;
+				}
+			});
+			const nuxtProject = merge({
+				...resolvedConfig,
+				extends: false,
+				test: {
+					...resolvedConfig.test,
+					name: "untestutils",
+					environment: UNIT_ENVIRONMENT,
+					include: []
+				}
+			}, resolvedConfig);
+			nuxtProject.test.include = ["**/*.{nuxt,untestutils}.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "{test,tests}/{nuxt,untestutils}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
+			const defaultProject = merge({
+				...resolvedConfig,
+				extends: false,
+				test: {
+					...resolvedConfig.test,
+					name: defaultEnvironment,
+					environment: defaultEnvironment,
+					exclude: [
+						"**/node_modules/**",
+						"**/dist/**",
+						"**/cypress/**",
+						"**/.{idea,git,cache,output,temp}/**",
+						"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
+						...nuxtProject.test.include
+					]
+				}
+			}, resolvedConfig);
+			delete resolvedConfig.test.name;
+			delete resolvedConfig.test.environment;
+			delete resolvedConfig.test.include;
+			delete resolvedConfig.test.exclude;
+			delete resolvedConfig.test.includeSource;
+			delete defaultProject.test.includeSource;
+			resolvedConfig.test.projects = [nuxtProject, defaultProject];
+		} else {
+			resolvedConfig.test.environment = UNIT_ENVIRONMENT;
+		}
+		warnIfE2ePluginMixed(resolvedConfig);
+		return resolvedConfig;
+	};
+}
+function isCoverageEnabled(config) {
+	if (config.test && "coverage" in config.test && config.test.coverage?.enabled) return true;
+	return process.argv.some((arg) => arg === "--coverage" || arg === "--coverage.enabled" || arg === "--coverage=true" || arg === "--coverage.enabled=true");
+}
+async function resolveConfig(config) {
+	const overrides = config.test?.environmentOptions?.nuxt?.overrides || {};
+	overrides.rootDir = config.test?.environmentOptions?.nuxt?.rootDir;
+	if (isCoverageEnabled(config)) {
+		if (overrides.sourcemap === undefined) overrides.sourcemap = { client: true };
+		else if (isObjectRecord(overrides.sourcemap) && overrides.sourcemap.client === undefined) overrides.sourcemap.client = true;
+	}
+	if (config.test?.setupFiles && !Array.isArray(config.test.setupFiles)) config.test.setupFiles = normalizeSetupFiles(config.test.setupFiles);
+	const resolvedConfig = defu(config, await getVitestConfigFromNuxt(undefined, {
+		dotenv: config.test?.environmentOptions?.nuxt?.dotenv,
+		nitroEnvironment: config.test?.environmentOptions?.nuxt?.nitroEnvironment,
+		overrides: deepCopy(overrides)
+	}));
+	resolvedConfig.plugins.push(NuxtVitestEnvironmentOptionsPlugin(resolvedConfig.test.environmentOptions));
+	if (resolvedConfig.test.browser?.enabled) {
+		if (vitestMajor >= 5) {
+			delete resolvedConfig.optimizeDeps?.noDiscovery;
+			resolvedConfig.optimizeDeps ??= {};
+			resolvedConfig.optimizeDeps.include ??= [];
+			resolvedConfig.optimizeDeps.include.push("@testing-library/vue", "h3-next/generic");
+		}
+		resolvedConfig.plugins.push({
+			name: "untestutils:browser-client-environment",
+			configEnvironment(name) {
+				if (name === "client") return { dev: { moduleRunnerTransform: false } };
+			}
+		});
+		if (resolvedConfig.test.environment === "untestutils") {
+			resolvedConfig.test.setupFiles = normalizeSetupFiles(resolvedConfig.test.setupFiles);
+			resolvedConfig.test.setupFiles.unshift(runtimeFile("browser-entry"));
+		}
+	}
+	return resolvedConfig;
+}
+function normalizeSetupFiles(setupFiles) {
+	return Array.isArray(setupFiles) ? setupFiles : [setupFiles].filter((file) => Boolean(file));
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}

package/dist/config/utils.d.mts

@@ -0,0 +1,12 @@
+export interface ApplyEnvOptions {
+	prefix: string;
+	altPrefix?: string;
+	env?: NodeJS.ProcessEnv;
+}
+export declare function applyEnv(obj: Record<string, unknown>, opts: ApplyEnvOptions, parentKey?: string): Record<string, unknown>;
+/**
+* Deep-copy plain objects and arrays, passing anything else through by reference.
+* `structuredClone` throws on proxies/functions common in `nuxt.options`.
+*/
+export declare function deepCopy<T>(input: T, seen?: WeakMap<object, unknown>): T;
+export declare function loadKit(rootDir: string): Promise<typeof import("@nuxt/kit")>;

package/dist/config/utils.d.ts

@@ -0,0 +1,13 @@
+export interface ApplyEnvOptions {
+    prefix: string;
+    altPrefix?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function applyEnv(obj: Record<string, unknown>, opts: ApplyEnvOptions, parentKey?: string): Record<string, unknown>;
+/**
+ * Deep-copy plain objects and arrays, passing anything else through by reference.
+ * `structuredClone` throws on proxies/functions common in `nuxt.options`.
+ */
+export declare function deepCopy<T>(input: T, seen?: WeakMap<object, unknown>): T;
+export declare function loadKit(rootDir: string): Promise<typeof import('@nuxt/kit')>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/config/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/config/utils.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAcD,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,IAAI,EAAE,eAAe,EACrB,SAAS,SAAK,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAczB;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAkC,GAAG,CAAC,CAiBxG;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,WAAW,CAAC,CAAC,CAsBlF"}

package/dist/config/utils.mjs

@@ -0,0 +1,79 @@
+import { destr } from "destr";
+import { snakeCase } from "scule";
+import { pathToFileURL } from "node:url";
+import { resolveModulePath } from "exsolve";
+function getEnv(key, opts) {
+	const env = opts.env ?? process.env;
+	const envKey = snakeCase(key).toUpperCase();
+	return destr(env[opts.prefix + envKey] ?? (opts.altPrefix ? env[opts.altPrefix + envKey] : undefined));
+}
+function isPlainObject(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+export function applyEnv(obj, opts, parentKey = "") {
+	for (const key in obj) {
+		const subKey = parentKey ? `${parentKey}_${key}` : key;
+		const envValue = getEnv(subKey, opts);
+		if (isPlainObject(obj[key])) {
+			const child = obj[key];
+			if (isPlainObject(envValue)) {
+				obj[key] = {
+					...child,
+					...envValue
+				};
+				applyEnv(obj[key], opts, subKey);
+			} else if (envValue === undefined) applyEnv(child, opts, subKey);
+			else obj[key] = envValue ?? obj[key];
+		} else obj[key] = envValue ?? obj[key];
+	}
+	return obj;
+}
+
+export function deepCopy(input, seen = new WeakMap()) {
+	if (typeof input !== "object" || input === null) return input;
+	const proto = Object.getPrototypeOf(input);
+	if (proto !== Object.prototype && proto !== Array.prototype && proto !== null) return input;
+	const existing = seen.get(input);
+	if (existing) return existing;
+	if (Array.isArray(input)) {
+		const copy = [];
+		seen.set(input, copy);
+		for (const item of input) copy.push(deepCopy(item, seen));
+		return copy;
+	}
+	const copy = {};
+	seen.set(input, copy);
+	for (const key in input) copy[key] = deepCopy(input[key], seen);
+	return copy;
+}
+export async function loadKit(rootDir) {
+	try {
+		const kitPath = resolveModulePath("@nuxt/kit", { from: tryResolveNuxt(rootDir) || rootDir });
+		let kit = await import(pathToFileURL(kitPath).href);
+		if (!kit.writeTypes) kit = {
+			...kit,
+			writeTypes: () => {
+				throw new Error("`writeTypes` is not available in this version of `@nuxt/kit`. Please upgrade to v3.7 or newer.");
+			}
+		};
+		return kit;
+	} catch (e) {
+		if (String(e).includes("Cannot find module '@nuxt/kit'")) throw new Error("`@untestutils/nuxt/config` requires `@nuxt/kit`. Install `nuxt` v3+ first.", { cause: e });
+		throw e;
+	}
+}
+function tryResolveNuxt(rootDir) {
+	for (const pkg of [
+		"nuxt-nightly",
+		"nuxt",
+		"nuxt3",
+		"nuxt-edge"
+	]) {
+		const path = resolveModulePath(pkg, {
+			from: rootDir,
+			try: true
+		});
+		if (path) return path;
+	}
+	return null;
+}

package/dist/environment/index.d.mts

@@ -0,0 +1,22 @@
+import { type EnvironmentOptions } from "../runtime/shared/environment.mjs";
+type VitestGlobal = typeof globalThis & {
+	console: Console;
+	IntersectionObserver?: typeof IntersectionObserver;
+};
+type DomEnvironmentOptions = EnvironmentOptions & {
+	happyDom?: ConstructorParameters<typeof import("happy-dom").Window>[0];
+	jsdom?: ConstructorParameters<typeof import("jsdom").JSDOM>[1] & {
+		html?: string;
+		userAgent?: string;
+		console?: boolean;
+		cookieJar?: boolean;
+	};
+};
+declare const environment: {
+	name: string;
+	viteEnvironment: "client";
+	setup(global: VitestGlobal, environmentOptions: DomEnvironmentOptions): Promise<{
+		teardown: () => void;
+	}>;
+};
+export default environment;

package/dist/environment/index.d.ts

@@ -0,0 +1,23 @@
+import { type EnvironmentOptions } from '../runtime/shared/environment';
+type VitestGlobal = typeof globalThis & {
+    console: Console;
+    IntersectionObserver?: typeof IntersectionObserver;
+};
+type DomEnvironmentOptions = EnvironmentOptions & {
+    happyDom?: ConstructorParameters<typeof import('happy-dom').Window>[0];
+    jsdom?: ConstructorParameters<typeof import('jsdom').JSDOM>[1] & {
+        html?: string;
+        userAgent?: string;
+        console?: boolean;
+        cookieJar?: boolean;
+    };
+};
+declare const environment: {
+    name: string;
+    viteEnvironment: "client";
+    setup(global: VitestGlobal, environmentOptions: DomEnvironmentOptions): Promise<{
+        teardown: () => void;
+    }>;
+};
+export default environment;
+//# sourceMappingURL=index.d.ts.map

package/dist/environment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/environment/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,kBAAkB,EAExB,MAAM,+BAA+B,CAAC;AAEvC,KAAK,YAAY,GAAG,OAAO,UAAU,GAAG;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;CACpD,CAAC;AACF,KAAK,qBAAqB,GAAG,kBAAkB,GAAG;IAChD,QAAQ,CAAC,EAAE,qBAAqB,CAAC,cAAc,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACvE,KAAK,CAAC,EAAE,qBAAqB,CAAC,cAAc,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG;QAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,CAAC;CACH,CAAC;AA6GF,QAAA,MAAM,WAAW;;;kBAIL,YAAY,sBACA,qBAAqB,GACxC,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;CAyDrC,CAAC;AAEF,eAAe,WAAW,CAAC"}