@untestutils/nuxt 0.5.0

package/dist/module/index.mjs

@@ -0,0 +1,294 @@
+
+import { extname, dirname, join, relative } from "pathe";
+import { readFileSync } from "node:fs";
+import { addVitePlugin, defineNuxtModule, resolveIgnorePatterns, resolvePath } from "@nuxt/kit";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+import { createUnplugin } from "unplugin";
+import { fileURLToPath } from "node:url";
+//#region mock transform plugin
+const PLUGIN_NAME = "untestutils:mock-transform";
+const HELPER_MOCK_IMPORT = "mockNuxtImport";
+const HELPER_UNMOCK_IMPORT = "unmockNuxtImport";
+const HELPER_MOCK_COMPONENT = "mockComponent";
+const HELPER_MOCK_HOIST = "__NUXT_VITEST_MOCKS";
+const HELPER_MOCK_HOIST_ORIGINAL = "__NUXT_VITEST_MOCKS_ORIGINAL";
+const HELPER_MOCK_HOIST_PREVIOUS = "__NUXT_VITEST_MOCKS_PREVIOUS";
+const HELPERS_NAME = [
+	HELPER_MOCK_IMPORT,
+	HELPER_UNMOCK_IMPORT,
+	HELPER_MOCK_COMPONENT
+];
+const createMockPlugin = (ctx) => createUnplugin(() => {
+	return {
+		name: PLUGIN_NAME,
+		enforce: "post",
+		vite: {
+			transform(code, id) {
+				if (!HELPERS_NAME.some((n) => code.includes(n))) return;
+				if (id.includes("/node_modules/")) return;
+				let ast;
+				try {
+					ast = this.parse(code);
+				} catch {
+					return;
+				}
+				let insertionPoint = 0;
+				let hasViImport = false;
+				const s = new MagicString(code);
+				const mocksImport = [];
+				const unmocksFrom = new Set();
+				const mocksComponent = [];
+				const importPathsList = new Set();
+				// @ts-expect-error mismatch between acorn/estree types
+				walk(ast, { enter: (node, parent) => {
+					const removeCallExpression = (start, end = start) => {
+						s.overwrite(isExpressionStatement(parent) ? startOf(parent) : startOf(start), isExpressionStatement(parent) ? endOf(parent) : endOf(end), "");
+					};
+					const parseMockImportTarget = (importTarget, helperName) => {
+						const name = isLiteral(importTarget) ? importTarget.value : isIdentifier(importTarget) ? importTarget.name : undefined;
+						if (typeof name !== "string") return this.error(new Error(`The first argument of ${helperName}() must be a string literal or mocked target`), startOf(importTarget));
+						return {
+							name,
+							importItem: ctx.imports.find((_) => name === (_.as || _.name))
+						};
+					};
+					if (isImportDeclaration(node)) {
+						if (node.source.value === "vitest" && !hasViImport) {
+							if (node.specifiers.find((i) => isImportSpecifier(i) && i.imported.type === "Identifier" && i.imported.name === "vi")) {
+								insertionPoint = endOf(node);
+								hasViImport = true;
+							}
+							return;
+						}
+					}
+					if (!isCallExpression(node)) return;
+					if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_IMPORT) {
+						if (node.arguments.length !== 2) return this.error(new Error(`${HELPER_MOCK_IMPORT}() should have exactly 2 arguments`), startOf(node));
+						const { name, importItem } = parseMockImportTarget(node.arguments[0], HELPER_MOCK_IMPORT);
+						if (!importItem) return this.error(`Cannot find import "${name}" to mock`);
+						removeCallExpression(node.arguments[0], node.arguments[1]);
+						mocksImport.push({
+							name,
+							import: importItem,
+							factory: code.slice(startOf(node.arguments[1]), endOf(node.arguments[1]))
+						});
+					}
+					if (isIdentifier(node.callee) && node.callee.name === HELPER_UNMOCK_IMPORT) {
+						if (node.arguments.length !== 1) return this.error(new Error(`${HELPER_UNMOCK_IMPORT}() should have exactly 1 argument`), startOf(node));
+						const { name, importItem } = parseMockImportTarget(node.arguments[0], HELPER_UNMOCK_IMPORT);
+						if (!importItem) return this.error(`Cannot find import "${name}" to unmock`);
+						removeCallExpression(node.arguments[0]);
+						unmocksFrom.add(importItem.from);
+						mocksImport.push({
+							name,
+							import: importItem,
+							factory: undefined
+						});
+					}
+					if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_COMPONENT) {
+						if (node.arguments.length !== 2) return this.error(new Error(`${HELPER_MOCK_COMPONENT}() should have exactly 2 arguments`), startOf(node));
+						const componentName = node.arguments[0];
+						if (!isLiteral(componentName) || typeof componentName.value !== "string") return this.error(new Error(`The first argument of ${HELPER_MOCK_COMPONENT}() must be a string literal`), startOf(componentName));
+						const pathOrName = componentName.value;
+						const path = ctx.components.find((_) => _.pascalName === pathOrName || _.kebabName === pathOrName)?.filePath || pathOrName;
+						removeCallExpression(node.arguments[1]);
+						mocksComponent.push({
+							path,
+							factory: code.slice(startOf(node.arguments[1]), endOf(node.arguments[1]))
+						});
+					}
+				} });
+				if (mocksImport.length === 0 && mocksComponent.length === 0) return;
+				const mockLines = [];
+				for (const from of unmocksFrom) mockLines.push(`vi.unmock(${JSON.stringify(from)});`);
+				for (const [from, mocks] of mapGroupBy(mocksImport, (mock) => mock.import.from)) {
+					importPathsList.add(from);
+					const quotedFrom = JSON.stringify(from);
+					const mockModuleEntry = `globalThis.${HELPER_MOCK_HOIST}[${quotedFrom}]`;
+					mockLines.push(`vi.mock(${quotedFrom}, async (importOriginal) => {`, `  if (!${mockModuleEntry} || ${unmocksFrom.has(from)}) {`, `    const original = await importOriginal()`, `    const previous = (${mockModuleEntry} ?? {}).${HELPER_MOCK_HOIST_PREVIOUS} ?? {}`, `    ${mockModuleEntry} = { ...original, ...previous }`, `    ${mockModuleEntry}.${HELPER_MOCK_HOIST_ORIGINAL} = { ...original }`, `    ${mockModuleEntry}.${HELPER_MOCK_HOIST_PREVIOUS} = { ...previous }`, `  }`);
+					for (const mock of mocks) {
+						const quotedName = JSON.stringify(mock.import.name);
+						const original = `${mockModuleEntry}.${HELPER_MOCK_HOIST_ORIGINAL}[${quotedName}]`;
+						if (mock.factory === undefined) mockLines.push(`  ${mockModuleEntry}[${quotedName}] = ${original}`, `  delete ${mockModuleEntry}.${HELPER_MOCK_HOIST_PREVIOUS}[${quotedName}]`);
+						else mockLines.push(`  ${mockModuleEntry}[${quotedName}] = await (${mock.factory})(${original})`, `  ${mockModuleEntry}.${HELPER_MOCK_HOIST_PREVIOUS}[${quotedName}] = ${mockModuleEntry}[${quotedName}]`);
+					}
+					mockLines.push(`  return ${mockModuleEntry}`);
+					mockLines.push(`});`);
+				}
+				if (mocksComponent.length) mockLines.push(...mocksComponent.flatMap((mock) => {
+					return [
+						`vi.mock(${JSON.stringify(mock.path)}, async () => {`,
+						`  const factory = (${mock.factory});`,
+						`  const result = typeof factory === 'function' ? await factory() : await factory`,
+						`  return 'default' in result ? result : { default: result }`,
+						"});"
+					];
+				}));
+				if (!mockLines.length) return;
+				s.appendLeft(insertionPoint, [
+					``,
+					`vi.hoisted(() => {`,
+					`  if(!globalThis.${HELPER_MOCK_HOIST}){`,
+					`    vi.stubGlobal(${JSON.stringify(HELPER_MOCK_HOIST)}, {})`,
+					`  }`,
+					`});`,
+					``
+				].join("\n"));
+				if (!hasViImport) s.prepend(`import {vi} from "vitest";\n`);
+				s.appendLeft(insertionPoint, "\n" + mockLines.join("\n") + "\n");
+				importPathsList.forEach((p) => {
+					s.append(`\n import ${JSON.stringify(p)};`);
+				});
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: true })
+				};
+			},
+			async configResolved(config) {
+				const plugins = config.plugins;
+				const vitestPlugins = plugins.filter((p) => (p.name === "vite:mocks" || p.name?.startsWith("vitest:")) && (p.enforce || "order" in p && p.order) === "post");
+				const lastNuxt = findLastIndex(plugins, (i) => Boolean(i.name?.startsWith("nuxt:")));
+				if (lastNuxt === -1) return;
+				for (const plugin of vitestPlugins) {
+					const index = plugins.indexOf(plugin);
+					if (index < lastNuxt) {
+						plugins.splice(index, 1);
+						plugins.splice(lastNuxt, 0, plugin);
+					}
+				}
+			}
+		}
+	};
+});
+function findLastIndex(arr, predicate) {
+	for (let i = arr.length - 1; i >= 0; i--) if (predicate(arr[i])) return i;
+	return -1;
+}
+const isImportDeclaration = (node) => node.type === "ImportDeclaration";
+const isImportSpecifier = (node) => node.type === "ImportSpecifier";
+const isCallExpression = (node) => node.type === "CallExpression";
+const isIdentifier = (node) => node.type === "Identifier";
+const isLiteral = (node) => node.type === "Literal";
+const isExpressionStatement = (node) => node?.type === "ExpressionStatement";
+const startOf = (node) => "range" in node && node.range ? node.range[0] : "start" in node ? node.start : 0;
+const endOf = (node) => "range" in node && node.range ? node.range[1] : "end" in node ? node.end : startOf(node);
+function mapGroupBy(items, keySelector) {
+	const map = new Map();
+	for (const item of items) {
+		const key = keySelector(item);
+		if (!map.has(key)) map.set(key, []);
+		map.get(key).push(item);
+	}
+	return map;
+}
+//#endregion
+//#region import mocking setup
+const isTestPluginFile = (src) => src.includes(".spec.") || src.includes(".test.");
+async function setupImportMocking(nuxt) {
+	const ctx = {
+		components: [],
+		imports: []
+	};
+	let importsCtx;
+	nuxt.hook("imports:context", async (ctx) => {
+		importsCtx = ctx;
+	});
+	nuxt.hook("ready", async () => {
+		ctx.imports = importsCtx ? await importsCtx.getImports() : [];
+	});
+	nuxt.hook("components:extend", (_) => {
+		ctx.components = _;
+	});
+	nuxt.hook("imports:sources", (presets) => {
+		const idx = presets.findIndex((p) => typeof p === "object" && p !== null && "imports" in p && p.imports?.includes("setInterval"));
+		if (idx !== -1) presets.splice(idx, 1);
+	});
+	nuxt.options.ignore = nuxt.options.ignore.filter((i) => i !== "**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}");
+	if (nuxt._ignore) for (const pattern of resolveIgnorePatterns("**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}")) nuxt._ignore.add(`!${pattern}`);
+	nuxt.hook("app:resolve", (app) => {
+		app.plugins = app.plugins.filter((plugin) => !isTestPluginFile(plugin.src));
+	});
+	addVitePlugin(createMockPlugin(ctx).vite());
+}
+//#endregion
+//#region nuxt root stub plugin
+const STUB_PLUGIN_NAME = "untestutils:nuxt-root-stub";
+const STUB_ID = "nuxt-vitest-app-entry";
+const NuxtRootStubPlugin = (options) => {
+	const extension = extname(options.entry);
+	const escapedExt = extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const entryPath = join(dirname(options.entry), STUB_ID + extension);
+	const idFilter = new RegExp(`${STUB_ID}(?:${escapedExt})?$`);
+	return {
+		name: STUB_PLUGIN_NAME,
+		enforce: "pre",
+		resolveId: {
+			filter: { id: idFilter },
+			async handler(id, importer) {
+				return importer?.endsWith("index.html") ? id : entryPath;
+			}
+		},
+		load: {
+			filter: { id: idFilter },
+			async handler() {
+				return readFileSync(options.entry, "utf-8").replace("#build/root-component.mjs", options.rootStubPath);
+			}
+		}
+	};
+};
+//#endregion
+function runtimeFile(subpath) {
+	const bare = subpath.replace(/^\.\//, "").replace(/\.mjs$/, "");
+	return fileURLToPath(new URL(`../runtime/${bare}.mjs`, import.meta.url));
+}
+//#region module
+const untestutilsModule = defineNuxtModule({
+	meta: {
+		name: "untestutils",
+		configKey: "testUtils",
+		version: "0.1.8"
+	},
+	defaults: {},
+	async setup(_options, nuxt) {
+		if (nuxt.options.test || nuxt.options.dev) await setupImportMocking(nuxt);
+		
+		
+		if (nuxt.options.test && !nuxt.options.dev) nuxt.hook("app:templates", (app) => {
+			const template = app.templates.find((t) => t.filename === "paths.mjs");
+			if (!template?.getContents) return;
+			const original = template.getContents;
+			const inlineAppConfig = JSON.stringify(nuxt.options.app);
+			template.getContents = async (data) => {
+				return (await original(data)).replace(/^import \{ useRuntimeConfig \} from ['"]nitropack\/runtime['"]\n?/m, "").replace(/const getAppConfig = \(\) => useRuntimeConfig\(\)\.app/, () => `const getAppConfig = () => (${inlineAppConfig})`);
+			};
+		});
+		if (nuxt.options.test || nuxt.options.dev) addVitePlugin(NuxtRootStubPlugin({
+			entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
+			rootStubPath: await resolvePath(runtimeFile("nuxt-root"))
+		}));
+		if (!nuxt.options.test && !nuxt.options.dev) {
+			nuxt.options.vite.define ||= {};
+			nuxt.options.vite.define["import.meta.vitest"] = "undefined";
+		}
+		nuxt.hook("prepare:types", (ctx) => {
+			ctx.references.push({ types: "vitest/import-meta" });
+			for (const tsConfig of [
+				ctx.tsConfig,
+				ctx.nodeTsConfig,
+				ctx.sharedTsConfig
+			]) {
+				if (!tsConfig) continue;
+				tsConfig.compilerOptions ||= {};
+				tsConfig.compilerOptions.allowImportingTsExtensions = true;
+			}
+			if (ctx.nodeTsConfig) {
+				ctx.nodeTsConfig.include ||= [];
+				ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
+				if (nuxt.options.workspaceDir !== nuxt.options.rootDir) ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
+			}
+		});
+	}
+});
+export default untestutilsModule;
+//#endregion

package/dist/runtime/browser-entry.d.mts

@@ -0,0 +1,5 @@
+/**
+* Optional browser-mode setup entry (Vitest browser provider).
+* Client DOM environment uses `./entry` instead.
+*/
+export {};

package/dist/runtime/browser-entry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Optional browser-mode setup entry (Vitest browser provider).
+ * Client DOM environment uses `./entry` instead.
+ */
+export {};
+//# sourceMappingURL=browser-entry.d.ts.map

package/dist/runtime/browser-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-entry.d.ts","sourceRoot":"","sources":["../../src/runtime/browser-entry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,CAAC"}

package/dist/runtime/browser-entry.mjs

@@ -0,0 +1,2 @@
+
+export {};

package/dist/runtime/entry.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=entry.d.ts.map

package/dist/runtime/entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/runtime/entry.ts"],"names":[],"mappings":""}

package/dist/runtime/entry.mjs

@@ -0,0 +1,9 @@
+import { setupNuxt } from "./shared/nuxt.mjs";
+import { beforeAll, vi } from "vitest";
+const win = globalThis.window;
+if (typeof globalThis !== "undefined" && win?.__NUXT_VITEST_ENVIRONMENT__) {
+	vi.resetModules();
+	beforeAll(async () => {
+		await setupNuxt();
+	});
+}

package/dist/runtime/index.d.mts

@@ -0,0 +1,81 @@
+import type { Component, VNode } from "vue";
+import type { MountingOptions, VueWrapper } from "@vue/test-utils";
+import type { render as testingLibraryRender } from "@testing-library/vue";
+type Awaitable<T> = T | Promise<T>;
+type RuntimeH3Event = {
+	method?: string;
+	path: string;
+	url?: URL;
+};
+type RuntimeEndpointHandler<T = unknown> = ((event: RuntimeH3Event) => Awaitable<T>) & {
+	__is_handler__?: true;
+};
+type MountSuspendedOptions<T extends Component> = MountingOptions<T> & {
+	route?: import("vue-router").RouteLocationRaw | false;
+	scoped?: boolean;
+	spy?: boolean;
+};
+type TestingLibraryRender = typeof testingLibraryRender;
+type RenderSuspendedOptions<T extends Component> = Parameters<TestingLibraryRender>[1] & MountSuspendedOptions<T>;
+type RenderSuspendedResult<T extends Component> = ReturnType<TestingLibraryRender> & {
+	rerender: (props?: Record<string, unknown>) => Promise<void>;
+};
+export type SuspendedHelpers = {
+	cleanupAll: () => void;
+	patchWrapperSetProps: (wrapper: object, setProps: (props: Record<string, unknown>) => void) => void;
+	wrapperSuspended: <TWrapper>(component: Component, options: MountingOptions<Component> & {
+		route?: import("vue-router").RouteLocationRaw | false;
+		scoped?: boolean;
+		spy?: boolean;
+	}, config: {
+		wrapperFn: (component: Component, options?: unknown) => TWrapper;
+		wrappedRender?: (render: () => VNode) => () => VNode;
+		suspendedHelperName: string;
+		clonedComponentName: string;
+	}) => Promise<{
+		wrapper: TWrapper & {
+			setupState: Record<string, unknown>;
+		};
+		setProps: (props: Record<string, unknown>) => void;
+	}>;
+};
+export interface RegisterEndpointOptions {
+	handler: RuntimeEndpointHandler;
+	method?: string;
+	once?: boolean;
+}
+/**
+* `registerEndpoint` lets you create a Nitro endpoint that returns mocked data.
+* Handy when a component fetches data from an API.
+*
+* @param url endpoint name (e.g. `/test/`)
+* @param options factory that returns mocked data, or an object with
+*   `handler`, `method` and `once`.
+*/
+export declare function registerEndpoint(url: string, options: RegisterEndpointOptions | RuntimeEndpointHandler): () => void;
+/**
+* `mockNuxtImport` mocks Nuxt's auto-import functionality. This is a macro that
+* is transformed to `vi.mock()` by `untestutils/module`.
+*/
+export declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: (original?: T) => T): void;
+/**
+* `unmockNuxtImport` reverts a previous `mockNuxtImport`. This is a macro that
+* is transformed by `untestutils/module`.
+*/
+export declare function unmockNuxtImport<T = unknown>(_target: string | T): void;
+/**
+* `mockComponent` replaces a component with a mock. This is a macro that is
+* transformed by `untestutils/module`.
+*/
+export declare function mockComponent(_path: string, _component: unknown): void;
+/**
+* `mountSuspended` mounts any Vue component within the Nuxt environment,
+* allowing async setup and access to injections from your Nuxt plugins.
+*/
+export declare function mountSuspended<T extends Component>(component: T, options?: MountSuspendedOptions<T>): Promise<VueWrapper>;
+/**
+* `renderSuspended` renders any Vue component within the Nuxt environment using
+* `@testing-library/vue`'s `render`. Requires `@testing-library/vue`.
+*/
+export declare function renderSuspended<T extends Component>(component: T, options?: RenderSuspendedOptions<T>): Promise<RenderSuspendedResult<T>>;
+export {};

package/dist/runtime/index.d.ts

@@ -0,0 +1,82 @@
+import type { Component, VNode } from 'vue';
+import type { MountingOptions, VueWrapper } from '@vue/test-utils';
+import type { render as testingLibraryRender } from '@testing-library/vue';
+type Awaitable<T> = T | Promise<T>;
+type RuntimeH3Event = {
+    method?: string;
+    path: string;
+    url?: URL;
+};
+type RuntimeEndpointHandler<T = unknown> = ((event: RuntimeH3Event) => Awaitable<T>) & {
+    __is_handler__?: true;
+};
+type MountSuspendedOptions<T extends Component> = MountingOptions<T> & {
+    route?: import('vue-router').RouteLocationRaw | false;
+    scoped?: boolean;
+    spy?: boolean;
+};
+type TestingLibraryRender = typeof testingLibraryRender;
+type RenderSuspendedOptions<T extends Component> = Parameters<TestingLibraryRender>[1] & MountSuspendedOptions<T>;
+type RenderSuspendedResult<T extends Component> = ReturnType<TestingLibraryRender> & {
+    rerender: (props?: Record<string, unknown>) => Promise<void>;
+};
+export type SuspendedHelpers = {
+    cleanupAll: () => void;
+    patchWrapperSetProps: (wrapper: object, setProps: (props: Record<string, unknown>) => void) => void;
+    wrapperSuspended: <TWrapper>(component: Component, options: MountingOptions<Component> & {
+        route?: import('vue-router').RouteLocationRaw | false;
+        scoped?: boolean;
+        spy?: boolean;
+    }, config: {
+        wrapperFn: (component: Component, options?: unknown) => TWrapper;
+        wrappedRender?: (render: () => VNode) => () => VNode;
+        suspendedHelperName: string;
+        clonedComponentName: string;
+    }) => Promise<{
+        wrapper: TWrapper & {
+            setupState: Record<string, unknown>;
+        };
+        setProps: (props: Record<string, unknown>) => void;
+    }>;
+};
+export interface RegisterEndpointOptions {
+    handler: RuntimeEndpointHandler;
+    method?: string;
+    once?: boolean;
+}
+/**
+ * `registerEndpoint` lets you create a Nitro endpoint that returns mocked data.
+ * Handy when a component fetches data from an API.
+ *
+ * @param url endpoint name (e.g. `/test/`)
+ * @param options factory that returns mocked data, or an object with
+ *   `handler`, `method` and `once`.
+ */
+export declare function registerEndpoint(url: string, options: RegisterEndpointOptions | RuntimeEndpointHandler): () => void;
+/**
+ * `mockNuxtImport` mocks Nuxt's auto-import functionality. This is a macro that
+ * is transformed to `vi.mock()` by `untestutils/module`.
+ */
+export declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: (original?: T) => T): void;
+/**
+ * `unmockNuxtImport` reverts a previous `mockNuxtImport`. This is a macro that
+ * is transformed by `untestutils/module`.
+ */
+export declare function unmockNuxtImport<T = unknown>(_target: string | T): void;
+/**
+ * `mockComponent` replaces a component with a mock. This is a macro that is
+ * transformed by `untestutils/module`.
+ */
+export declare function mockComponent(_path: string, _component: unknown): void;
+/**
+ * `mountSuspended` mounts any Vue component within the Nuxt environment,
+ * allowing async setup and access to injections from your Nuxt plugins.
+ */
+export declare function mountSuspended<T extends Component>(component: T, options?: MountSuspendedOptions<T>): Promise<VueWrapper>;
+/**
+ * `renderSuspended` renders any Vue component within the Nuxt environment using
+ * `@testing-library/vue`'s `render`. Requires `@testing-library/vue`.
+ */
+export declare function renderSuspended<T extends Component>(component: T, options?: RenderSuspendedOptions<T>): Promise<RenderSuspendedResult<T>>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"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"}

package/dist/runtime/index.mjs

@@ -0,0 +1,156 @@
+
+import { h, nextTick } from "vue";
+import { mount } from "@vue/test-utils";
+
+function importSuspended() {
+	return import("./suspended");
+}
+//#region registerEndpoint
+function getEndpointRegistry() {
+	const app = window.__app ?? (window.__app = {});
+	return app._registeredEndpointRegistry ||= {};
+}
+function findEndpointRegistryHandlers(url) {
+	const endpointRegistry = getEndpointRegistry();
+	const pathname = url.replace(/[?#].*$/, "");
+	for (const [key, handlers] of Object.entries(endpointRegistry)) {
+		if (key === url || key === pathname) {
+			if (handlers?.length) return handlers;
+		}
+	}
+}
+
+export function registerEndpoint(url, options) {
+	const app = typeof globalThis !== "undefined" && "window" in globalThis ? globalThis.window?.__app : undefined;
+	if (!app) {
+		throw new Error("registerEndpoint() can only be used in an `untestutils` runtime environment");
+	}
+	const config = typeof options === "function" ? {
+		url,
+		handler: options,
+		method: undefined,
+		once: false
+	} : {
+		...options,
+		url
+	};
+	config.handler = Object.assign(config.handler, { __is_handler__: true });
+	const endpointRegistry = getEndpointRegistry();
+	endpointRegistry[url] ||= [];
+	endpointRegistry[url].push(config);
+	window.__registry.add(url);
+	app._registered ||= registerGlobalHandler(app);
+	return () => {
+		endpointRegistry[url]?.splice(endpointRegistry[url].indexOf(config), 1);
+		if (endpointRegistry[url]?.length === 0) window.__registry.delete(url);
+	};
+}
+const handler = Object.assign(async (event) => {
+	const registeredHandlers = findEndpointRegistryHandlers("url" in event && event.url ? (event.url.pathname + event.url.search).replace(/^\/_/, "") : event.path.replace(/^\/_/, ""));
+	const latestHandler = [...registeredHandlers || []].reverse().find((config) => config.method ? event.method === config.method : true);
+	if (!latestHandler) return;
+	const result = await latestHandler.handler(event);
+	if (!latestHandler.once) return result;
+	const index = registeredHandlers?.indexOf(latestHandler);
+	if (index === undefined || index === -1) return result;
+	registeredHandlers?.splice(index, 1);
+	if (registeredHandlers?.length === 0) window.__registry.delete(latestHandler.url);
+	return result;
+}, { __is_handler__: true });
+function registerGlobalHandler(app) {
+	app.use(handler, { match: (eventOrPath, _event) => {
+		const url = typeof eventOrPath === "string" ? eventOrPath.replace(/^\/_/, "") : eventOrPath.url ? (eventOrPath.url.pathname + eventOrPath.url.search).replace(/^\/_/, "") : eventOrPath.path.replace(/^\/_/, "");
+		const event = _event ?? (typeof eventOrPath === "string" ? undefined : eventOrPath);
+		return findEndpointRegistryHandlers(url)?.some((config) => config.method ? event?.method === config.method : true) ?? false;
+	} });
+	return true;
+}
+//#endregion
+//#region mock macros
+
+export function mockNuxtImport(_target, _factory) {
+	throw new Error("mockNuxtImport() is a macro and it did not get transpiled. Ensure `untestutils/module` is enabled in your Nuxt test config.");
+}
+
+export function unmockNuxtImport(_target) {
+	throw new Error("unmockNuxtImport() is a macro and it did not get transpiled. Ensure `untestutils/module` is enabled in your Nuxt test config.");
+}
+
+export function mockComponent(_path, _component) {
+	throw new Error("mockComponent() is a macro and it did not get transpiled. Ensure `untestutils/module` is enabled in your Nuxt test config.");
+}
+//#endregion
+//#region mountSuspended
+
+export async function mountSuspended(component, options = {}) {
+	const { cleanupAll, patchWrapperSetProps, wrapperSuspended } = await importSuspended();
+	const suspendedHelperName = "MountSuspendedHelper";
+	const clonedComponentName = "MountSuspendedComponent";
+	cleanupAll();
+	const { wrapper, setProps } = await wrapperSuspended(component, options, {
+		wrapperFn: (component, options) => mount(component, options),
+		suspendedHelperName,
+		clonedComponentName
+	});
+	patchWrapperSetProps(wrapper, setProps);
+	return wrappedMountedWrapper(wrapper, wrapper.findComponent({ name: clonedComponentName }));
+}
+function wrappedMountedWrapper(wrapper, component) {
+	const wrapperProps = [
+		"setProps",
+		"emitted",
+		"setupState",
+		"unmount"
+	];
+	return new Proxy(wrapper, { get: (_, prop, receiver) => {
+		if (prop === "getCurrentComponent") return getCurrentComponentPatchedProxy;
+		const target = wrapperProps.includes(prop) ? wrapper : Reflect.has(component, prop) ? component : wrapper;
+		const value = Reflect.get(target, prop, receiver);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+	function getCurrentComponentPatchedProxy() {
+		const currentComponent = component.getCurrentComponent();
+		return new Proxy(currentComponent, { get: (target, prop, receiver) => {
+			const value = Reflect.get(target, prop, receiver);
+			if (prop === "proxy" && value) return new Proxy(value, { get(o, p, r) {
+				if (!Reflect.has(currentComponent.props, p)) {
+					const setupState = wrapper.setupState;
+					if (setupState && typeof setupState === "object") {
+						if (Reflect.has(setupState, p)) return Reflect.get(setupState, p, r);
+					}
+				}
+				return Reflect.get(o, p, r);
+			} });
+			return value;
+		} });
+	}
+}
+//#endregion
+//#region renderSuspended
+
+export async function renderSuspended(component, options = {}) {
+	const { cleanupAll, wrapperSuspended } = await importSuspended();
+	const wrapperId = "test-wrapper";
+	const suspendedHelperName = "RenderHelper";
+	const clonedComponentName = "RenderSuspendedComponent";
+	
+	const { render: wrapperFn } = await import("@testing-library/vue");
+	cleanupAll();
+	document.getElementById(wrapperId)?.remove();
+	const { wrapper, setProps } = await wrapperSuspended(component, options, {
+		wrapperFn: (component, options) => wrapperFn(component, options),
+		wrappedRender: (render) => () => h({
+			inheritAttrs: false,
+			render: () => h("div", { id: wrapperId }, render())
+		}),
+		suspendedHelperName,
+		clonedComponentName
+	});
+	const renderResult = wrapper;
+	renderResult.rerender = async (props = {}) => {
+		setProps(props);
+		await nextTick();
+	};
+	return renderResult;
+}
+//#endregion