@nuxt/test-utils 3.22.0 → 3.23.0

package/dist/config.d.mts

@@ -46,6 +46,7 @@ interface NuxtEnvironmentOptions {
      * @default 'happy-dom'
      */
     domEnvironment?: 'happy-dom' | 'jsdom';
+    h3Version?: 1 | 2;
     mock?: {
         intersectionObserver?: boolean;
         indexedDb?: boolean;

package/dist/config.mjs

@@ -3,11 +3,12 @@ import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
 import { createResolver, findPath } from '@nuxt/kit';
+import { resolveModulePath } from 'exsolve';
+import { getPackageInfoSync } from 'local-pkg';
 import { a as applyEnv, l as loadKit } from './shared/test-utils.BIY9XRkB.mjs';
 import 'destr';
 import 'scule';
 import 'node:url';
-import 'exsolve';
 
 const PLUGIN_NAME = "nuxt:vitest:nuxt-environment-options";
 const STUB_ID = "nuxt-vitest-environment-options";
@@ -94,6 +95,21 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   }
   delete options.viteConfig.root;
   options.viteConfig.plugins = (options.viteConfig.plugins || []).filter((p) => !p || !("name" in 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 h3Info = getPackageInfoSync("h3", {
+    paths: nitroPath ? [nitroPath] : options.nuxt.options.modulesDir
+  });
   const resolver = createResolver(import.meta.url);
   const resolvedConfig = defu(
     // overrides
@@ -188,6 +204,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         environmentOptions: {
           nuxt: {
             rootId: options.nuxt.options.app.rootId || void 0,
+            h3Version: h3Info?.version?.startsWith("2.") ? 2 : 1,
             mock: {
               intersectionObserver: true,
               indexedDb: false

package/dist/e2e.d.mts

@@ -1,9 +1,10 @@
-import { T as TestOptions, b as TestContext, a as TestHooks } from './shared/test-utils.ZByFDqps.mjs';
-export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils.ZByFDqps.mjs';
+import { T as TestOptions, b as TestContext, a as TestHooks } from './shared/test-utils.C9GKP_T5.mjs';
+export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils.C9GKP_T5.mjs';
 import { LogType } from 'consola';
 import 'playwright-core';
 import '@nuxt/schema';
 import 'tinyexec';
+import 'ofetch';
 
 declare function createTestContext(options: Partial<TestOptions>): TestContext;
 declare function useTestContext(): TestContext;

package/dist/e2e.mjs

@@ -1,6 +1,6 @@
-export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.D2ZzXztg.mjs';
-import { u as useTestContext } from './shared/test-utils.C_clWQBc.mjs';
-export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.C_clWQBc.mjs';
+export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.5cnw0YZR.mjs';
+import { u as useTestContext } from './shared/test-utils.BsmyE2FA.mjs';
+export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.BsmyE2FA.mjs';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { distDir } from '#dirs';

package/dist/experimental.mjs

@@ -1,6 +1,6 @@
 import { resolve } from 'pathe';
 import { stringifyQuery } from 'ufo';
-import { $ as $fetch, u as useTestContext } from './shared/test-utils.C_clWQBc.mjs';
+import { $ as $fetch, u as useTestContext } from './shared/test-utils.BsmyE2FA.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/module.mjs

@@ -1,13 +1,16 @@
-import { resolveIgnorePatterns, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath, logger } from '@nuxt/kit';
-import { extname, join, dirname, resolve, relative } from 'pathe';
-import { provider, isCI } from 'std-env';
+import { resolveIgnorePatterns, logger, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath } from '@nuxt/kit';
+import { extname, join, dirname, relative, resolve } from 'pathe';
+import { isCI, hasTTY, provider } from 'std-env';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
 import { l as loadKit } from './shared/test-utils.BIY9XRkB.mjs';
-import { readFileSync } from 'node:fs';
+import { readFileSync, existsSync, promises } from 'node:fs';
+import process$1 from 'node:process';
+import { intro, multiselect, isCancel, cancel, select, confirm, outro } from '@clack/prompts';
+import { colors } from 'consola/utils';
+import { detectPackageManager, addDependency } from 'nypm';
 import { h } from 'vue';
-import { defineEventHandler } from 'h3';
 import { debounce } from 'perfect-debounce';
 import { fork } from 'node:child_process';
 import { c as createVitestTestSummary, l as listenCliMessages, s as sendMessageToCli } from './shared/test-utils.DDUpsMYL.mjs';
@@ -79,7 +82,6 @@ const createMockPlugin = (ctx) => createUnplugin(() => {
           }
           const importItem = ctx.imports.find((_) => name === (_.as || _.name));
           if (!importItem) {
-            console.log({ imports: ctx.imports });
             return this.error(`Cannot find import "${name}" to mock`);
           }
           s.overwrite(
@@ -323,6 +325,446 @@ const NuxtRootStubPlugin = (options) => {
   };
 };
 
+function generateVitestConfig(answers) {
+  let config = `import { fileURLToPath } from 'node:url'
+import { defineConfig } from 'vitest/config'
+import { defineVitestProject } from '@nuxt/test-utils/config'`;
+  if (answers.browserMode) {
+    config += `
+import { playwright } from '@vitest/browser-playwright'`;
+  }
+  config += `
+
+export default defineConfig({
+`;
+  config += `  test: {
+    projects: [
+`;
+  if (answers.testingScope.includes("unit")) {
+    config += `      {
+        test: {
+          name: 'unit',
+          include: ['test/unit/*.{test,spec}.ts'],
+          environment: 'node',
+        },
+      },
+`;
+  }
+  config += `      await defineVitestProject({
+        test: {
+          name: 'nuxt',
+          include: ['test/nuxt/*.{test,spec}.ts'],
+          environment: 'nuxt',
+          environmentOptions: {
+            nuxt: {
+              rootDir: fileURLToPath(new URL('.', import.meta.url)),${answers.browserMode ? "" : `
+              domEnvironment: '${answers.domEnvironment || "happy-dom"}',`}
+            },
+          },${answers.browserMode ? `
+          browser: {
+            enabled: true,
+            provider: playwright(),
+            instances: [
+              { browser: 'chromium' },
+            ],
+          },` : ""}
+        },
+      }),
+`;
+  if (answers.testingScope.includes("e2e") && answers.e2eRunner === "vitest") {
+    config += `      {
+        test: {
+          name: 'e2e',
+          include: ['test/e2e/*.{test,spec}.ts'],
+          environment: 'node',
+        },
+      },
+`;
+  }
+  config += `    ],
+`;
+  if (answers.coverage) {
+    config += `    coverage: {
+      enabled: true,
+      provider: 'v8',
+    },
+`;
+  }
+  config += `  },
+`;
+  config += `})
+`;
+  return config;
+}
+function generatePlaywrightConfig() {
+  return `import { fileURLToPath } from 'node:url'
+import { defineConfig, devices } from '@playwright/test'
+import type { ConfigOptions } from '@nuxt/test-utils/playwright'
+
+export default defineConfig<ConfigOptions>({
+  testDir: './tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    trace: 'on-first-retry',
+    nuxt: {
+      rootDir: fileURLToPath(new URL('.', import.meta.url)),
+    },
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+})
+`;
+}
+function getDependencies(answers) {
+  const dependencies = [];
+  if (answers.testingScope.includes("unit") || answers.testingScope.includes("runtime")) {
+    dependencies.push("vitest", "@vue/test-utils");
+    if (answers.domEnvironment) {
+      dependencies.push(answers.domEnvironment);
+    }
+    if (answers.browserMode) {
+      dependencies.push("@vitest/browser-playwright");
+    }
+  }
+  if (answers.e2eRunner === "playwright") {
+    dependencies.push("@playwright/test", "playwright-core");
+  } else if (answers.e2eRunner === "cucumber") {
+    dependencies.push("@cucumber/cucumber");
+  } else if (answers.e2eRunner === "jest") {
+    dependencies.push("@jest/globals");
+  }
+  if (answers.coverage) {
+    dependencies.push("@vitest/coverage-v8");
+  }
+  return dependencies;
+}
+function getPackageScripts(answers) {
+  const scripts = {};
+  if (answers.testingScope.includes("unit") || answers.testingScope.includes("runtime")) {
+    scripts.test = "vitest";
+    scripts["test:watch"] = "vitest --watch";
+    if (answers.coverage) {
+      scripts["test:coverage"] = "vitest --coverage";
+    }
+    if (answers.testingScope.includes("unit")) {
+      scripts["test:unit"] = "vitest --project unit";
+    }
+    scripts["test:nuxt"] = "vitest --project nuxt";
+    if (answers.testingScope.includes("e2e") && answers.e2eRunner === "vitest") {
+      scripts["test:e2e"] = "vitest --project e2e";
+    }
+  }
+  if (answers.e2eRunner === "playwright") {
+    scripts["test:e2e"] = "playwright test";
+    scripts["test:e2e:ui"] = "playwright test --ui";
+  }
+  return scripts;
+}
+async function runInstallWizard(nuxt) {
+  if (isCI || !hasTTY || nuxt.options.test) {
+    return;
+  }
+  if (nuxt.options.workspaceDir && nuxt.options.workspaceDir !== nuxt.options.rootDir) {
+    logger.info("Monorepo detected. Skipping setup wizard.");
+    return;
+  }
+  const rootDir = nuxt.options.rootDir;
+  const hasVitestConfig = existsSync(join(rootDir, "vitest.config.ts")) || existsSync(join(rootDir, "vitest.config.js")) || existsSync(join(rootDir, "vitest.config.mts")) || existsSync(join(rootDir, "vitest.config.mjs"));
+  const hasPlaywrightConfig = existsSync(join(rootDir, "playwright.config.ts")) || existsSync(join(rootDir, "playwright.config.js"));
+  if (hasVitestConfig || hasPlaywrightConfig) {
+    logger.info("Test configuration already exists. Skipping setup wizard.");
+    return;
+  }
+  intro(colors.bold(colors.cyan("\u{1F9EA} Nuxt Test Utils Setup")));
+  const answers = {};
+  const testingScope = await multiselect({
+    message: "What kind of tests will you need?",
+    options: [
+      {
+        value: "runtime",
+        label: "Runtime",
+        hint: "components or composables running in a Nuxt runtime environment"
+      },
+      {
+        value: "unit",
+        label: "Unit tests",
+        hint: "pure functions or build-time/Node tests"
+      },
+      {
+        value: "e2e",
+        label: "End-to-end",
+        hint: "full application flows in browser"
+      }
+    ],
+    required: true
+  });
+  if (isCancel(testingScope)) {
+    cancel("Setup cancelled.");
+    process$1.exit(0);
+  }
+  answers.testingScope = testingScope;
+  const needsVitest = answers.testingScope.includes("unit") || answers.testingScope.includes("runtime");
+  const needsE2E = answers.testingScope.includes("e2e");
+  if (answers.testingScope.includes("runtime")) {
+    const domEnvironment = await select({
+      message: "Which Vitest environment would you like to use for runtime tests?",
+      options: [
+        {
+          value: "happy-dom",
+          label: "happy-dom",
+          hint: "recommended - faster, lighter"
+        },
+        {
+          value: "jsdom",
+          label: "jsdom",
+          hint: "more complete browser simulation"
+        },
+        {
+          value: "browser",
+          label: "browser mode",
+          hint: "real browser with Playwright"
+        }
+      ],
+      initialValue: "happy-dom"
+    });
+    if (isCancel(domEnvironment)) {
+      cancel("Setup cancelled.");
+      process$1.exit(0);
+    }
+    if (domEnvironment === "browser") {
+      answers.browserMode = true;
+    } else {
+      answers.domEnvironment = domEnvironment;
+    }
+  }
+  if (needsE2E) {
+    const e2eRunner = await select({
+      message: "Which end-to-end test runner would you like to use?",
+      options: [
+        {
+          value: "playwright",
+          label: "Playwright",
+          hint: "recommended - modern, multi-browser"
+        },
+        {
+          value: "vitest",
+          label: "Vitest",
+          hint: "same runner as unit tests"
+        },
+        {
+          value: "cucumber",
+          label: "Cucumber",
+          hint: "behavior-driven development"
+        },
+        {
+          value: "jest",
+          label: "Jest",
+          hint: "legacy test runner"
+        }
+      ],
+      initialValue: "playwright"
+    });
+    if (isCancel(e2eRunner)) {
+      cancel("Setup cancelled.");
+      process$1.exit(0);
+    }
+    answers.e2eRunner = e2eRunner;
+  }
+  if (needsVitest) {
+    const coverage = await confirm({
+      message: "Would you like to set up test coverage?",
+      initialValue: false
+    });
+    if (isCancel(coverage)) {
+      cancel("Setup cancelled.");
+      process$1.exit(0);
+    }
+    answers.coverage = coverage;
+  }
+  const exampleTests = await confirm({
+    message: "Create example test files?",
+    initialValue: true
+  });
+  if (isCancel(exampleTests)) {
+    cancel("Setup cancelled.");
+    process$1.exit(0);
+  }
+  answers.exampleTests = exampleTests;
+  await performSetup(nuxt, answers);
+  outro(colors.green("\u2728 Test setup complete!"));
+}
+async function performSetup(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const packageManager = await detectPackageManager(rootDir);
+  logger.info("Installing dependencies...");
+  const dependencies = getDependencies(answers);
+  if (dependencies.length > 0) {
+    try {
+      await addDependency(dependencies, {
+        cwd: rootDir,
+        dev: true,
+        packageManager
+      });
+    } catch (error) {
+      logger.error("Failed to install dependencies:", error);
+      return;
+    }
+  }
+  if (answers.testingScope.includes("unit") || answers.testingScope.includes("runtime")) {
+    await createVitestConfig(nuxt, answers);
+  }
+  if (answers.e2eRunner === "playwright") {
+    await createPlaywrightConfig(nuxt);
+  }
+  await createTestDirectories(nuxt, answers);
+  if (answers.exampleTests) {
+    await createExampleTests(nuxt, answers);
+  }
+  await updatePackageScripts(nuxt, answers);
+  await updateGitignore(nuxt, answers);
+}
+async function createVitestConfig(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const configPath = join(rootDir, "vitest.config.ts");
+  const config = generateVitestConfig(answers);
+  await promises.writeFile(configPath, config, "utf-8");
+  logger.success(`Created ${colors.cyan(relative(process$1.cwd(), configPath))}`);
+}
+async function createPlaywrightConfig(nuxt) {
+  const rootDir = nuxt.options.rootDir;
+  const configPath = join(rootDir, "playwright.config.ts");
+  const config = generatePlaywrightConfig();
+  await promises.writeFile(configPath, config, "utf-8");
+  logger.success(`Created ${colors.cyan(relative(process$1.cwd(), configPath))}`);
+}
+async function createTestDirectories(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  if (answers.testingScope.includes("unit")) {
+    const unitDir = join(rootDir, "test/unit");
+    await promises.mkdir(unitDir, { recursive: true });
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), unitDir))}`);
+  }
+  if (answers.testingScope.includes("runtime")) {
+    const nuxtDir = join(rootDir, "test/nuxt");
+    await promises.mkdir(nuxtDir, { recursive: true });
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), nuxtDir))}`);
+  }
+  if (answers.testingScope.includes("e2e")) {
+    const e2eDir = answers.e2eRunner === "playwright" ? join(rootDir, "tests") : join(rootDir, "test/e2e");
+    await promises.mkdir(e2eDir, { recursive: true });
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), e2eDir))}`);
+  }
+}
+async function createExampleTests(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  if (answers.testingScope.includes("unit")) {
+    const unitTestPath = join(rootDir, "test/unit/example.test.ts");
+    const unitTest = `import { describe, expect, it } from 'vitest'
+
+describe('example unit test', () => {
+  it('should pass', () => {
+    expect(1 + 1).toBe(2)
+  })
+})
+`;
+    await promises.writeFile(unitTestPath, unitTest, "utf-8");
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), unitTestPath))}`);
+  }
+  if (answers.testingScope.includes("runtime")) {
+    const componentTestPath = join(rootDir, "test/nuxt/component.test.ts");
+    const componentTest = `import { describe, expect, it } from 'vitest'
+import { mountSuspended } from '@nuxt/test-utils/runtime'
+import { defineComponent, h } from 'vue'
+
+describe('component test example', () => {
+  it('can mount components', async () => {
+    const TestComponent = defineComponent({
+      setup() {
+        return () => h('div', 'Hello Nuxt!')
+      },
+    })
+    
+    const component = await mountSuspended(TestComponent)
+    
+    expect(component.text()).toBe('Hello Nuxt!')
+  })
+})
+`;
+    await promises.writeFile(componentTestPath, componentTest, "utf-8");
+    logger.success(`Created ${colors.cyan(relative(process$1.cwd(), componentTestPath))}`);
+  }
+  if (answers.testingScope.includes("e2e")) {
+    if (answers.e2eRunner === "playwright") {
+      const e2eTestPath = join(rootDir, "tests/example.spec.ts");
+      const e2eTest = `import { expect, test } from '@nuxt/test-utils/playwright'
+
+test('example e2e test', async ({ page, goto }) => {
+  await goto('/', { waitUntil: 'hydration' })
+  await expect(page).toHaveTitle(/Nuxt/)
+})
+`;
+      await promises.writeFile(e2eTestPath, e2eTest, "utf-8");
+      logger.success(`Created ${colors.cyan(relative(process$1.cwd(), e2eTestPath))}`);
+    } else {
+      const e2eTestPath = join(rootDir, "test/e2e/example.test.ts");
+      const e2eTest = `import { describe, expect, it } from 'vitest'
+import { $fetch, setup } from '@nuxt/test-utils/e2e'
+
+describe('example e2e test', async () => {
+  await setup()
+
+  it('renders the index page', async () => {
+    const html = await $fetch('/')
+    expect(html).toContain('Nuxt')
+  })
+})
+`;
+      await promises.writeFile(e2eTestPath, e2eTest, "utf-8");
+      logger.success(`Created ${colors.cyan(relative(process$1.cwd(), e2eTestPath))}`);
+    }
+  }
+}
+async function updatePackageScripts(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const packageJsonPath = join(rootDir, "package.json");
+  const packageJson = JSON.parse(await promises.readFile(packageJsonPath, "utf-8"));
+  packageJson.scripts = packageJson.scripts || {};
+  const newScripts = getPackageScripts(answers);
+  Object.assign(packageJson.scripts, newScripts);
+  await promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+  logger.success("Updated package.json scripts");
+}
+async function updateGitignore(nuxt, answers) {
+  const rootDir = nuxt.options.rootDir;
+  const gitignorePath = join(rootDir, ".gitignore");
+  let gitignore = "";
+  if (existsSync(gitignorePath)) {
+    gitignore = await promises.readFile(gitignorePath, "utf-8");
+  }
+  const lines = [];
+  if (answers.coverage && !gitignore.includes("coverage")) {
+    lines.push("# Test coverage", "coverage/", "");
+  }
+  if (answers.e2eRunner === "playwright") {
+    if (!gitignore.includes("playwright-report")) {
+      lines.push("# Playwright", "playwright-report/", "test-results/", "");
+    }
+  }
+  if (lines.length > 0) {
+    gitignore += "\n" + lines.join("\n");
+    await promises.writeFile(gitignorePath, gitignore, "utf-8");
+    logger.success("Updated .gitignore");
+  }
+}
+
 async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
   const iframeSrc = "/__test_utils_vitest__/";
   const updateTabs = debounce(() => {
@@ -339,9 +781,7 @@ async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
   });
   addDevServerHandler({
     route: iframeSrc,
-    handler: defineEventHandler(
-      () => iframeContentHtml(vitestWrapper.uiUrl)
-    )
+    handler: Object.assign(() => iframeContentHtml(vitestWrapper.uiUrl), { __is_handler__: true })
   });
   vitestWrapper.ons({
     started() {
@@ -521,15 +961,23 @@ function vitestWrapper(options) {
   };
 }
 
+const version = "3.23.0";
+const pkg = {
+	version: version};
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
-    configKey: "testUtils"
+    configKey: "testUtils",
+    version: pkg.version
   },
   defaults: {
     startOnBoot: false,
     logToConsole: false
   },
+  async onInstall(nuxt) {
+    await runInstallWizard(nuxt);
+  },
   async setup(options, nuxt) {
     if (nuxt.options.test || nuxt.options.dev) {
       await setupImportMocking(nuxt);

package/dist/playwright.d.mts

@@ -1,9 +1,10 @@
 import * as _playwright_test from '@playwright/test';
 export { expect } from '@playwright/test';
 import { Response } from 'playwright-core';
-import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.ZByFDqps.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.C9GKP_T5.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
+import 'ofetch';
 
 type ConfigOptions = {
     nuxt: Partial<TestOptions$1> | undefined;

package/dist/playwright.mjs

@@ -1,7 +1,7 @@
 import defu from 'defu';
 import { test as test$1 } from '@playwright/test';
 export { expect } from '@playwright/test';
-import { w as waitForHydration, d as createTest } from './shared/test-utils.D2ZzXztg.mjs';
+import { w as waitForHydration, d as createTest } from './shared/test-utils.5cnw0YZR.mjs';
 import 'node:path';
 import 'ufo';
 import 'std-env';
@@ -11,7 +11,7 @@ import 'destr';
 import 'scule';
 import 'node:url';
 import 'exsolve';
-import { d as url } from './shared/test-utils.C_clWQBc.mjs';
+import { d as url } from './shared/test-utils.BsmyE2FA.mjs';
 import 'pathe';
 import '#dirs';
 import './shared/test-utils.BIY9XRkB.mjs';