@untestutils/nuxt 0.5.0

package/dist/runtime/suspended.mjs

@@ -0,0 +1,259 @@
+
+import { Suspense, effectScope, getCurrentInstance, h, nextTick, onErrorCaptured, reactive } from "vue";
+import { vi } from "vitest";
+import { defineComponent, tryUseNuxtApp, useNuxtApp, useRouter } from "#imports";
+import NuxtRoot from "#build/root-component.mjs";
+//#region src/runtime-utils/components/RouterLink.ts
+function getUseLink(nuxtApp) {
+	const linkComponent = nuxtApp.vueApp._context.components.RouterLink;
+	if (!linkComponent || typeof linkComponent !== "object") return void 0;
+	if (typeof linkComponent.useLink !== "function") return void 0;
+	return linkComponent.useLink.bind(linkComponent);
+}
+const RouterLink = defineComponent({
+	functional: true,
+	props: {
+		to: {
+			type: [String, Object],
+			required: true
+		},
+		custom: Boolean,
+		replace: Boolean,
+		activeClass: String,
+		exactActiveClass: String,
+		ariaCurrentValue: String
+	},
+	setup: (props, { slots }) => {
+		const useLink = getUseLink(useNuxtApp());
+		if (!useLink) {
+			const navigate = () => {};
+			const router = useRouter();
+			return () => {
+				const route = router.resolve(props.to);
+				return props.custom ? slots.default?.({
+					href: route.href,
+					navigate,
+					route
+				}) : h("a", {
+					href: route.href,
+					onClick: (e) => {
+						e.preventDefault();
+					}
+				}, slots);
+			};
+		}
+		const link = useLink(props);
+		return () => {
+			const route = link.route.value;
+			const href = link.href.value;
+			const isActive = link.isActive.value;
+			const isExactActive = link.isExactActive.value;
+			return props.custom ? slots.default?.({
+				href,
+				navigate: link.navigate,
+				route,
+				isActive,
+				isExactActive
+			}) : h("a", {
+				href,
+				onClick: (e) => {
+					e.preventDefault();
+					return link.navigate(e);
+				}
+			}, slots);
+		};
+	}
+});
+//#endregion
+//#region src/runtime-utils/utils/suspended.ts
+function resolveVueApp() {
+	return tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
+}
+
+function patchWrapperSetProps(wrapper, setProps) {
+	Object.assign(wrapper, { __setProps: setProps });
+}
+function cleanupAll() {
+	for (const fn of (window.__cleanup || []).splice(0)) fn();
+}
+function addCleanup(fn) {
+	window.__cleanup ||= [];
+	window.__cleanup.push(fn);
+}
+function removeCleanup(fn) {
+	const index = window.__cleanup?.indexOf(fn) ?? -1;
+	if (index !== -1) window.__cleanup?.splice(index, 1);
+}
+function runEffectScope(fn, register) {
+	const scope = effectScope();
+	register(() => scope.stop());
+	return scope.run(fn);
+}
+function wrapperSuspended(component, options = {}, { wrapperFn, wrappedRender = (fn) => fn, suspendedHelperName, clonedComponentName, stubRouterLink = true }) {
+	const vueApp = resolveVueApp();
+	const globalProperties = makeAllPropertiesEnumerable(vueApp.config.globalProperties);
+	const resolvedOptions = options ?? {};
+	const ownCleanups = [];
+	function registerCleanup(fn) {
+		ownCleanups.push(fn);
+		addCleanup(fn);
+	}
+	function cleanup() {
+		for (const fn of ownCleanups.splice(0)) {
+			removeCleanup(fn);
+			fn();
+		}
+	}
+	const { props = {}, attrs = {} } = resolvedOptions;
+	const { route = "/", scoped = false, spy = false, ...wrapperFnOptions } = resolvedOptions;
+	const componentOptions = component;
+	const { setup: componentSetup, ...componentRest } = componentOptions;
+	let wrappedInstance = null;
+	let setupContext;
+	let setupState = {};
+	const setProps = reactive({});
+	function patchInstanceAppContext() {
+		const app = getCurrentInstance()?.appContext.app;
+		if (!app) return;
+		for (const [key, value] of Object.entries(vueApp)) {
+			if (key in app) continue;
+			app[key] = value;
+		}
+	}
+	const ClonedComponent = {
+		components: {},
+		...component,
+		name: clonedComponentName,
+		async setup(props, instanceContext) {
+			const currentInstance = getCurrentInstance();
+			if (currentInstance) currentInstance.emit = (event, ...args) => {
+				setupContext?.emit(event, ...args);
+			};
+			if (!componentSetup) return;
+			let result = scoped ? await runEffectScope(() => componentSetup(props, setupContext), registerCleanup) : await componentSetup(props, setupContext);
+			if (wrappedInstance?.exposed) instanceContext.expose(wrappedInstance.exposed);
+			if (result && typeof result === "object") {
+				if (spy) result = vi.mockObject(result, { spy: true });
+				setupState = result;
+			} else setupState = {};
+			return result;
+		}
+	};
+	const SuspendedHelper = {
+		name: suspendedHelperName,
+		render: () => "",
+		async setup() {
+			if (route) await useRouter().replace(route);
+			return () => h(ClonedComponent, {
+				...props,
+				...setProps,
+				...attrs
+			}, setupContext?.slots);
+		}
+	};
+	return new Promise((resolve, reject) => {
+		let isMountSettled = false;
+		const wrapper = wrapperFn({
+			inheritAttrs: false,
+			__cssModules: componentRest.__cssModules,
+			setup: (props, ctx) => {
+				patchInstanceAppContext();
+				wrappedInstance = getCurrentInstance();
+				setupContext = ctx;
+				const nuxtRootSetupResult = runEffectScope(() => typeof NuxtRoot === "object" && "setup" in NuxtRoot && typeof NuxtRoot.setup === "function" ? NuxtRoot.setup(props, {
+					...ctx,
+					expose: () => {}
+				}) : undefined, registerCleanup);
+				onErrorCaptured((error, ...args) => {
+					if (isMountSettled) return;
+					isMountSettled = true;
+					try {
+						wrappedInstance?.appContext.config.errorHandler?.(error, ...args);
+						reject(error);
+					} catch (error) {
+						reject(error);
+					}
+					return false;
+				});
+				return nuxtRootSetupResult;
+			},
+			render: wrappedRender(() => h(Suspense, { onResolve: () => nextTick().then(() => {
+				if (isMountSettled) return;
+				isMountSettled = true;
+				const typedWrapper = wrapper;
+				typedWrapper.setupState = setupState;
+				resolve({
+					wrapper: typedWrapper,
+					setProps: (props) => {
+						Object.assign(setProps, props);
+					},
+					cleanup
+				});
+			}) }, { default: () => h(SuspendedHelper) }))
+		}, {
+			...wrapperFnOptions,
+			global: mergeComponentMountingGlobalOptions(wrapperFnOptions.global, {
+				config: { globalProperties },
+				directives: vueApp._context.directives,
+				provide: vueApp._context.provides,
+				stubs: {
+					Suspense: false,
+					[SuspendedHelper.name]: false,
+					[ClonedComponent.name]: false
+				},
+				components: {
+					...vueApp._context.components,
+					...stubRouterLink ? { RouterLink } : {}
+				}
+			})
+		});
+	});
+}
+function mergeComponentMountingGlobalOptions(options = {}, defaults = {}) {
+	const compilerOptions = {
+		...defaults.config?.compilerOptions,
+		...options.config?.compilerOptions
+	};
+	return {
+		...options,
+		mixins: [...defaults.mixins || [], ...options.mixins || []],
+		stubs: {
+			...defaults.stubs,
+			...Array.isArray(options.stubs) ? Object.fromEntries(options.stubs.map((n) => [n, true])) : options.stubs
+		},
+		plugins: [...defaults.plugins || [], ...options.plugins || []],
+		components: {
+			...defaults.components,
+			...options.components
+		},
+		provide: {
+			...defaults.provide,
+			...options.provide
+		},
+		mocks: {
+			...defaults.mocks,
+			...options.mocks
+		},
+		config: {
+			...defaults.config,
+			...options.config,
+			...Object.keys(compilerOptions).length ? { compilerOptions } : void 0,
+			globalProperties: {
+				...defaults.config?.globalProperties,
+				...options.config?.globalProperties
+			}
+		},
+		directives: {
+			...defaults.directives,
+			...options.directives
+		}
+	};
+}
+function makeAllPropertiesEnumerable(target) {
+	return {
+		...target,
+		...Object.fromEntries(Object.getOwnPropertyNames(target).map((key) => [key, target[key]]))
+	};
+}
+//#endregion
+export { cleanupAll, patchWrapperSetProps, wrapperSuspended };

package/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "@untestutils/nuxt",
+  "version": "0.5.0",
+  "description": "Nuxt recipes + in-process unit runtime, config, module, and Vitest environment",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.mjs",
+      "default": "./dist/runtime/index.mjs"
+    },
+    "./runtime/entry": {
+      "types": "./dist/runtime/entry.d.ts",
+      "import": "./dist/runtime/entry.mjs",
+      "default": "./dist/runtime/entry.mjs"
+    },
+    "./runtime/nuxt-root": {
+      "types": "./dist/runtime/nuxt-root.d.ts",
+      "import": "./dist/runtime/nuxt-root.mjs",
+      "default": "./dist/runtime/nuxt-root.mjs"
+    },
+    "./runtime/mocks/vue-devtools": {
+      "types": "./dist/runtime/mocks/vue-devtools.d.ts",
+      "import": "./dist/runtime/mocks/vue-devtools.mjs",
+      "default": "./dist/runtime/mocks/vue-devtools.mjs"
+    },
+    "./runtime/browser-entry": {
+      "types": "./dist/runtime/browser-entry.d.ts",
+      "import": "./dist/runtime/browser-entry.mjs",
+      "default": "./dist/runtime/browser-entry.mjs"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.mjs",
+      "default": "./dist/config/index.mjs"
+    },
+    "./module": {
+      "types": "./dist/module/index.d.ts",
+      "import": "./dist/module/index.mjs",
+      "default": "./dist/module/index.mjs"
+    },
+    "./environment": {
+      "types": "./dist/environment/index.d.ts",
+      "import": "./dist/environment/index.mjs",
+      "default": "./dist/environment/index.mjs"
+    },
+    "./vitest-environment": {
+      "types": "./dist/environment/index.d.ts",
+      "import": "./dist/environment/index.mjs",
+      "default": "./dist/environment/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.5.2",
+    "@nuxt/schema": "^4.5.2",
+    "c12": "^3.0.0",
+    "defu": "^6.1.7",
+    "destr": "^2.0.5",
+    "estree-walker": "^3.0.3",
+    "exsolve": "^1.1.1",
+    "fake-indexeddb": "^6.2.5",
+    "local-pkg": "^1.2.1",
+    "magic-string": "^0.30.0",
+    "node-fetch-native": "^1.6.7",
+    "node-mock-http": "^1.0.5",
+    "ofetch": "^1.5.1",
+    "pathe": "^2.0.3",
+    "radix3": "^1.1.2",
+    "scule": "^1.3.0",
+    "ufo": "^1.6.4",
+    "unimport": "^6.5.0",
+    "unplugin": "^3.3.0",
+    "@untestutils/core": "0.5.0"
+  },
+  "devDependencies": {
+    "@types/estree": "^1.0.8",
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^26.6.1",
+    "@vue/test-utils": "^2.5.1",
+    "obuild": "^0.4.40",
+    "publint": "^0.3.24",
+    "rollup": "^4.63.3",
+    "typescript": "^6.0.3",
+    "vue": "^3.5.0",
+    "vue-router": "^4.6.3"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": "^4.5.2",
+    "@testing-library/vue": "^8.0.0",
+    "@vue/test-utils": "^2.4.0",
+    "h3": ">=1.15.0",
+    "happy-dom": ">=20.0.0",
+    "jsdom": ">=27.0.0",
+    "nuxt": "^3.0.0 || ^4.0.0",
+    "vitest": "^4.0.0 || ^5.0.0",
+    "vue": "^3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@testing-library/vue": {
+      "optional": true
+    },
+    "h3": {
+      "optional": true
+    },
+    "happy-dom": {
+      "optional": true
+    },
+    "jsdom": {
+      "optional": true
+    },
+    "nuxt": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "homepage": "https://s00d.github.io/untestutils/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/s00d/untestutils.git",
+    "directory": "packages/nuxt"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "obuild && tsc -p tsconfig.build.json",
+    "publint": "publint --strict"
+  }
+}