@poveste/plugin-vue 0.20.0 → 0.21.0

package/dist/client/server/Story.d.ts

@@ -1,5 +1,5 @@
-import type { ServerStory } from '@poveste/shared';
-import type { PropType } from 'vue';
+import type { AutoDocsSection, ServerStory } from '@poveste/shared';
+import type { Component, PropType } from 'vue';
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     title: {
         type: StringConstructor;
@@ -29,6 +29,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    autoDocs: {
+        type: PropType<boolean | AutoDocsSection[]>;
+        default: undefined;
+    };
+    component: {
+        type: PropType<Component | Component[]>;
+        default: undefined;
+    };
     meta: {
         type: PropType<ServerStory["meta"]>;
         default: undefined;
@@ -64,18 +72,28 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    autoDocs: {
+        type: PropType<boolean | AutoDocsSection[]>;
+        default: undefined;
+    };
+    component: {
+        type: PropType<Component | Component[]>;
+        default: undefined;
+    };
     meta: {
         type: PropType<ServerStory["meta"]>;
         default: undefined;
     };
 }>> & Readonly<{}>, {
+    component: Component | Component[];
     meta: import("poveste").StoryMeta | undefined;
+    autoDocs: boolean | AutoDocsSection[];
     id: string;
     title: string;
     group: string;
     layout: import("poveste").StoryLayout | undefined;
+    docsOnly: boolean;
     icon: string;
     iconColor: string;
-    docsOnly: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/client/server/collect.d.ts

@@ -0,0 +1,14 @@
+import type { ServerRunPayload } from '@poveste/shared';
+import type { App, Component } from 'vue';
+/**
+ * Collects a story file's component that is already imported. Story tests get
+ * it from their own import, so no `moduleId` has to be a URL in the browser.
+ */
+export declare function collectComponent(Comp: Component & {
+    doc?: string;
+}, { file, storyData, el }: ServerRunPayload, hooks?: {
+    /** Before the setup hooks, so what they report is seen. */
+    beforeSetup?: (app: App) => void;
+    /** After them, so what it adds fills gaps rather than replacing the app's own. */
+    afterSetup?: (app: App) => void;
+}): Promise<void>;

package/dist/client-dependencies.d.ts

@@ -0,0 +1,2 @@
+/** What the client code imports from npm, for the optimizer to bundle up front. */
+export declare const CLIENT_DEPENDENCIES: string[];

package/dist/client-dependencies.js

@@ -0,0 +1,2 @@
+/** What the client code imports from npm, for the optimizer to bundle up front. */
+export const CLIENT_DEPENDENCIES = ['change-case'];

package/dist/docgen/events.d.ts

@@ -0,0 +1,9 @@
+import type ts from 'typescript';
+export interface EventDoc {
+    description: string;
+    tags: {
+        name: string;
+        text?: string;
+    }[];
+}
+export declare function readEventDocs(typescript: typeof ts, program: ts.Program | undefined, file: string): Map<string, EventDoc>;

package/dist/docgen/events.js

@@ -0,0 +1,45 @@
+/*
+ * vue-component-meta reads an event's JSDoc off the component's `$emit` signatures,
+ * and those are Vue's own `EmitFn` in `runtime-core.d.ts`, built from the declared
+ * type: the comment is never on them, so every event came back without a
+ * description or a tag (#1462). Volar keeps the `defineEmits` type argument, comments
+ * and all, as a `__VLS_Emit` alias in the generated code, and this reads it there,
+ * through the same program, so an emits type imported from another file resolves too.
+ */
+// Not only at the top: a `generic` setup, or a `<script>` block beside `<script setup>`,
+// puts the setup, and the alias with it, inside the component's initializer.
+function findEmitAlias(typescript, node) {
+    if (typescript.isTypeAliasDeclaration(node) && node.name.text === '__VLS_Emit') {
+        return node;
+    }
+    return typescript.forEachChild(node, child => findEmitAlias(typescript, child));
+}
+export function readEventDocs(typescript, program, file) {
+    const docs = new Map();
+    const source = program?.getSourceFile(file);
+    const alias = source && findEmitAlias(typescript, source);
+    if (!program || !alias) {
+        return docs;
+    }
+    const checker = program.getTypeChecker();
+    const type = checker.getTypeAtLocation(alias.name);
+    const tagsOf = (tags) => tags.map(({ name, text }) => text?.length ? { name, text: typescript.displayPartsToString(text) } : { name });
+    // `change: [value: string]`
+    for (const property of type.getProperties()) {
+        docs.set(property.name, {
+            description: typescript.displayPartsToString(property.getDocumentationComment(checker)),
+            tags: tagsOf(property.getJsDocTags(checker)),
+        });
+    }
+    // `(event: 'change', value: string): void`
+    for (const signature of type.getCallSignatures()) {
+        const event = signature.parameters[0] && checker.getTypeOfSymbol(signature.parameters[0]);
+        if (event?.isStringLiteral()) {
+            docs.set(event.value, {
+                description: typescript.displayPartsToString(signature.getDocumentationComment(checker)),
+                tags: tagsOf(signature.getJsDocTags()),
+            });
+        }
+    }
+    return docs;
+}

package/dist/docgen/extractor.d.ts

@@ -1,5 +1,4 @@
 import type { DocgenExtractor, DocgenExtractorContext } from '@poveste/shared';
-export declare function findTsconfig(root: string): string | undefined;
 /**
  * Runs in the docgen worker. `vue-component-meta` is imported here rather than at
  * the top, so a book without TypeScript fails this one request, answered with its

package/dist/docgen/extractor.js

@@ -1,28 +1,47 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'pathe';
+import { createRequire } from 'node:module';
+import { findTsconfig } from 'poveste/docgen';
+import { readEventDocs } from './events.js';
+import { readGeneric } from './generic.js';
 import { toComponentDoc } from './meta.js';
-// `tsconfig.app.json` first: Vite's Vue template splits the app's settings into it
-// and leaves `tsconfig.json` holding only references, which type nothing.
-const TSCONFIGS = ['tsconfig.app.json', 'tsconfig.json'];
+import { readSlotProps } from './slots.js';
 const SOURCE = /\.(?:vue|[cm]?[jt]sx?)$/;
-export function findTsconfig(root) {
-    return TSCONFIGS.map(name => join(root, name)).find(file => existsSync(file));
-}
 /**
  * Runs in the docgen worker. `vue-component-meta` is imported here rather than at
  * the top, so a book without TypeScript fails this one request, answered with its
  * error, and keeps its runtime props.
  */
 export async function createExtractor(context) {
-    const { createChecker, createCheckerByJson } = await import('vue-component-meta');
+    const { createChecker, createCheckerByJson, TypeMeta } = await import('vue-component-meta');
     const options = (context.options ?? {});
     const checkerOptions = { forceUseTs: true, printer: { newLine: 1 } };
     const tsconfig = findTsconfig(context.root);
+    // The copy vue-component-meta loaded, so the syntax kinds match the program it builds.
+    const typescript = createRequire(createRequire(import.meta.url).resolve('vue-component-meta'))('typescript');
     const checker = tsconfig
         ? createChecker(tsconfig, checkerOptions)
         : createCheckerByJson(context.root, { include: ['**/*'], exclude: ['node_modules'] }, checkerOptions);
+    // A script file is offered for its default export, which is a component only when it is
+    // `defineComponent`'s: a function, a helper or a plain object throws or reads as Unknown.
+    function scriptComponent(file) {
+        try {
+            const meta = checker.getComponentMeta(file, 'default');
+            return meta.type === TypeMeta.Unknown ? undefined : meta;
+        }
+        catch {
+            return undefined;
+        }
+    }
     return {
-        extract: file => toComponentDoc(checker.getComponentMeta(file), options),
+        extract(file) {
+            const meta = file.endsWith('.vue') ? checker.getComponentMeta(file) : scriptComponent(file);
+            if (!meta) {
+                return undefined;
+            }
+            const doc = toComponentDoc(meta, options, meta.events.length ? readEventDocs(typescript, checker.getProgram(), file) : undefined, slot => readSlotProps(typescript, checker.getProgram(), slot));
+            const generic = file.endsWith('.vue') ? readGeneric(readFileSync(file, 'utf8')) : undefined;
+            return generic ? { ...doc, generic } : doc;
+        },
         update(file) {
             if (!SOURCE.test(file)) {
                 return;

package/dist/docgen/generic.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The type parameters a `<script setup generic="…">` declares, constraints and defaults
+ * included, so a table that prints `T | T[]` can say what `T` may be (#1436).
+ */
+export declare function readGeneric(source: string): string | undefined;

package/dist/docgen/generic.js

@@ -0,0 +1,19 @@
+// A tag's attributes may hold a `>`, as `generic="T extends Record<string, unknown>"` does,
+// so a quoted value is read whole rather than ending the tag.
+const SCRIPT_TAG = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+const SETUP = /(?:^|\s)setup(?=[\s=]|$)/;
+const GENERIC = /(?:^|\s)generic\s*=\s*(?:"([^"]*)"|'([^']*)')/;
+/**
+ * The type parameters a `<script setup generic="…">` declares, constraints and defaults
+ * included, so a table that prints `T | T[]` can say what `T` may be (#1436).
+ */
+export function readGeneric(source) {
+    for (const [, attributes] of source.matchAll(SCRIPT_TAG)) {
+        if (SETUP.test(attributes)) {
+            const found = GENERIC.exec(attributes);
+            const generic = (found?.[1] ?? found?.[2])?.replace(/\s+/g, ' ').trim();
+            return generic || undefined;
+        }
+    }
+    return undefined;
+}

package/dist/docgen/meta.d.ts

@@ -1,9 +1,12 @@
-import type { ComponentDoc } from '@poveste/shared';
-import type { ComponentMeta } from 'vue-component-meta';
-export interface VueDocgenOptions {
-    /** Packages whose props count although they are declared under `node_modules`. */
-    allow?: string[];
-}
-/** A default as written, without the quoting a tag or the printer added. */
-export declare function normalizeDefault(value: string): string;
-export declare function toComponentDoc(meta: ComponentMeta, options?: VueDocgenOptions): ComponentDoc;
+import type { ComponentDoc, DocSlot } from '@poveste/shared';
+import type { DocgenOptions } from 'poveste/docgen';
+import type { ComponentMeta, SlotMeta } from 'vue-component-meta';
+import type { EventDoc } from './events.js';
+export type VueDocgenOptions = DocgenOptions;
+/**
+ * An event's payload, which vue-component-meta prints as the tuple it is declared as,
+ * `[event: KeyboardEvent]`, written as the parameter list a handler takes (#1436). Only
+ * when the outer brackets enclose the whole of it: `[a: A] | [b: B]` is left as it is.
+ */
+export declare function asParameters(type: string): string;
+export declare function toComponentDoc(meta: ComponentMeta, options?: VueDocgenOptions, eventDocs?: Map<string, EventDoc>, slotProps?: (slot: SlotMeta) => DocSlot['props'] & {}): ComponentDoc;

package/dist/docgen/meta.js

@@ -1,20 +1,12 @@
-const HIDDEN_TAGS = ['internal', 'private'];
-// Aliases: bits-ui mixes them about 50/50, reka-ui and nuxt/ui write `@defaultValue`.
-const DEFAULT_TAGS = ['default', 'defaultValue'];
+import { declaredOnlyInPackages, DEFAULT_TAGS, HIDDEN_TAGS, normalizeDefault } from 'poveste/docgen';
 function tagsOf(tags) {
     return tags.map(({ name, text }) => text === undefined ? { name } : { name, text });
 }
 function isHidden(tags) {
     return tags.some(tag => HIDDEN_TAGS.includes(tag.name));
 }
-/** Declared only in installed packages none of which is allowed: an inherited attribute. */
 function isInherited(prop, allow) {
-    const files = prop.getDeclarations().map(declaration => declaration.file.replaceAll('\\', '/'));
-    return files.length > 0 && files.every(file => file.includes('/node_modules/') && !allow.some(pkg => file.includes(`/node_modules/${pkg}/`)));
-}
-/** A default as written, without the quoting a tag or the printer added. */
-export function normalizeDefault(value) {
-    return value.trim().replace(/^`(.*)`$/s, '$1').replace(/^'(.*)'$/s, '"$1"');
+    return declaredOnlyInPackages(prop.getDeclarations().map(declaration => declaration.file), allow);
 }
 function toProp(prop) {
     const defaultTag = prop.tags.find(tag => DEFAULT_TAGS.includes(tag.name))?.text;
@@ -40,11 +32,45 @@ function toMember(member) {
         tags: tagsOf(member.tags),
     };
 }
-export function toComponentDoc(meta, options = {}) {
+/**
+ * An event's payload, which vue-component-meta prints as the tuple it is declared as,
+ * `[event: KeyboardEvent]`, written as the parameter list a handler takes (#1436). Only
+ * when the outer brackets enclose the whole of it: `[a: A] | [b: B]` is left as it is.
+ */
+export function asParameters(type) {
+    if (!type.startsWith('[')) {
+        return type;
+    }
+    let depth = 0;
+    for (let i = 0; i < type.length; i++) {
+        if ('[(<{'.includes(type[i])) {
+            depth++;
+        }
+        // The `>` of an arrow, `() => void`, closes nothing.
+        else if (']>)}'.includes(type[i]) && !(type[i] === '>' && type[i - 1] === '=') && --depth === 0) {
+            return i === type.length - 1 ? `(${type.slice(1, -1)})` : type;
+        }
+    }
+    return type;
+}
+// What vue-component-meta returns for an event is empty wherever its own reading is (#1462).
+function withDocs(event, doc) {
+    return {
+        name: event.name,
+        description: event.description || doc?.description || '',
+        type: asParameters(event.type),
+        tags: event.tags.length ? event.tags : doc?.tags ?? [],
+    };
+}
+function toSlot(slot, slotProps) {
+    const props = slotProps(slot);
+    return { ...toMember(slot), ...props.length ? { props } : {} };
+}
+export function toComponentDoc(meta, options = {}, eventDocs = new Map(), slotProps = () => []) {
     const allow = options.allow ?? [];
     return {
         props: meta.props.filter(prop => !prop.global && !isHidden(prop.tags) && !isInherited(prop, allow)).map(toProp),
-        slots: meta.slots.filter(slot => !isHidden(slot.tags)).map(toMember),
-        events: meta.events.filter(event => !isHidden(event.tags)).map(toMember),
+        slots: meta.slots.filter(slot => !isHidden(slot.tags)).map(slot => toSlot(slot, slotProps)),
+        events: meta.events.map(event => withDocs(event, eventDocs.get(event.name))).filter(event => !isHidden(event.tags)).map(toMember),
     };
 }

package/dist/docgen/slots.d.ts

@@ -0,0 +1,6 @@
+import type { DocSlot } from '@poveste/shared';
+import type ts from 'typescript';
+import type { SlotMeta } from 'vue-component-meta';
+type DocSlotProp = NonNullable<DocSlot['props']>[number];
+export declare function readSlotProps(typescript: typeof ts, program: ts.Program | undefined, slot: SlotMeta): DocSlotProp[];
+export {};

package/dist/docgen/slots.js

@@ -0,0 +1,21 @@
+export function readSlotProps(typescript, program, slot) {
+    if (!program) {
+        return [];
+    }
+    const checker = program.getTypeChecker();
+    let type;
+    try {
+        type = slot.getTypeObject();
+    }
+    catch {
+        return [];
+    }
+    return type.getProperties().map((property) => {
+        const description = typescript.displayPartsToString(property.getDocumentationComment(checker));
+        return {
+            name: property.name,
+            type: checker.typeToString(checker.getTypeOfSymbol(property)),
+            ...description ? { description } : {},
+        };
+    });
+}

package/dist/index.node.d.ts

@@ -1,3 +1,5 @@
 import type { Plugin } from 'poveste';
 export declare function HstVue(): Plugin;
 export * from './helpers.js';
+export { povesteTesting } from './testing/vite.js';
+export type { PovesteTestingOptions } from './testing/vite.js';

package/dist/index.node.js

@@ -1,13 +1,13 @@
-import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { CLIENT_DEPENDENCIES } from './client-dependencies.js';
 import generateStoryCommand from './commands/generate-story.server.js';
-import { typescriptProblem } from './docgen/typescript.js';
 import { VUE_SETUP_HOOK_NAMES } from './setup-hooks.js';
 import { listComponentFiles } from './util/list-components.js';
+import { projectVueVersion } from './util/project-vue.js';
 import { VAPOR_INTEROP_ID, vaporInteropModule, withoutVaporPlugin } from './util/vapor.js';
 import { requireVuePlugin } from './util/vue-plugin.js';
+const SCRIPT_COMPONENT = /(?<!\.d)\.[cm]?[jt]sx?$/;
 export function HstVue() {
     return {
         name: '@poveste/plugin-vue',
@@ -25,6 +25,14 @@ export function HstVue() {
         config() {
             return {
                 vite: {
+                    // The chrome's client code imports these, and the scan never reaches them: it
+                    // loads through virtual modules, so a cold `poveste dev` found them only when the
+                    // page asked, re-bundled and reloaded a Nuxt reader's first page (#1477). Named
+                    // through this package, which every Vue, Nuxt and Quasar book lists, because the
+                    // book itself cannot resolve them under pnpm.
+                    optimizeDeps: {
+                        include: CLIENT_DEPENDENCIES.map(name => `@poveste/plugin-vue > ${name}`),
+                    },
                     plugins: [
                         requireVuePlugin(),
                         withoutVaporPlugin(),
@@ -56,11 +64,14 @@ export function HstVue() {
                 },
             };
         },
-        // A story file documents nothing: it names the components that do.
+        // A story file documents nothing: it names the components that do. A script file is
+        // offered too, for a component written with `defineComponent` (#1463); the extractor
+        // answers nothing for one that isn't.
         docgen: {
-            match: file => file.endsWith('.vue') && !file.endsWith('.story.vue'),
+            match: file => (file.endsWith('.vue') || SCRIPT_COMPONENT.test(file)) && !/\.story\.[^/]+$/.test(file) && !file.includes('/node_modules/'),
             module: fileURLToPath(new URL('./docgen/extractor.js', import.meta.url)),
-            unavailable: () => typescriptProblem(),
+            // `vue-component-meta` requires `typescript` from where it is installed, an optional peer npm does not add.
+            typescript: createRequire(import.meta.url).resolve('vue-component-meta'),
         },
         supportPlugin: {
             id: 'vue3',
@@ -82,13 +93,5 @@ export function HstVue() {
         },
     };
 }
-function projectVueVersion(root) {
-    try {
-        const manifest = createRequire(join(root, 'package.json')).resolve('vue/package.json');
-        return JSON.parse(readFileSync(manifest, 'utf8')).version;
-    }
-    catch {
-        return undefined;
-    }
-}
 export * from './helpers.js';
+export { povesteTesting } from './testing/vite.js';

package/dist/testing/index.d.ts

@@ -0,0 +1,28 @@
+import type { Component } from 'vue';
+export interface TestStoriesOptions {
+    /** The outer `describe`'s name. The story file's name by default. */
+    name?: string;
+    /**
+     * How long a variant's setup may take to settle, in milliseconds: an
+     * `initState` or an async `setup()` still pending then fails the test.
+     */
+    timeout?: number;
+}
+type StoryComponent = Component & {
+    __file?: string;
+    doc?: string;
+};
+/**
+ * Turns a story file into one test per variant. Each test renders the variant
+ * the way the preview does, and fails on what the preview would only log: an
+ * error from setup or render, a rejected `initState`, or a `[Vue warn]`.
+ *
+ * ```ts
+ * import { testStories } from '@poveste/plugin-vue/testing'
+ * import BaseButton from './BaseButton.story.vue'
+ *
+ * testStories(BaseButton)
+ * ```
+ */
+export declare function testStories(component: StoryComponent, options?: TestStoriesOptions): void;
+export {};

package/dist/testing/vite.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from 'vite';
+export interface PovesteTestingOptions {
+    /** The book's poveste config file. Found from the Vite root by default. */
+    configFile?: string;
+}
+/**
+ * What a story needs in the user's own Vitest to render as `poveste dev` renders
+ * it: the book's setup file and the modules Poveste's client imports, with
+ * Poveste's own packages inlined so Vitest can serve those, and `vue` and the
+ * setup file pre-bundled for browser mode. Nothing else: no alias and no change
+ * to how anything resolves, so the test sees the project's Vite config as the
+ * project wrote it.
+ *
+ * Setup code that a plugin generates for `poveste dev`, such as the Nuxt app
+ * `@poveste/plugin-nuxt` boots, is left to the test environment, which already
+ * provides it: `@nuxt/test-utils`'s `nuxt` environment does in a Nuxt project.
+ */
+export declare function povesteTesting(options?: PovesteTestingOptions): Plugin;

package/dist/testing/vite.js

@@ -0,0 +1,171 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { clientConfig, VIRTUAL_IDS } from '@poveste/shared';
+import { getDefaultConfig, loadConfigFile, mergeConfig, resolveConfigFile } from 'poveste';
+import { VUE_SETUP_HOOK_NAMES } from '../setup-hooks.js';
+import { projectVueVersion } from '../util/project-vue.js';
+import { VAPOR_INTEROP_ID, vaporInteropModule } from '../util/vapor.js';
+const EMPTY_SETUP_ID = '\0poveste-testing:empty-setup';
+const CONFIG_RESOLVED_ID = `\0${VIRTUAL_IDS.config}`;
+const ENVIRONMENT_ID = 'virtual:$poveste-testing-environment';
+// Vitest hands what it finds in `node_modules` to Node, which can't load the
+// `virtual:` modules these packages import, so in a book that installs them no test
+// ran (#1503). The workspace links them, and Vitest inlines a linked package.
+const POVESTE_PACKAGES = [/\/node_modules\/poveste\//, /\/node_modules\/@poveste\//];
+const EMPTY_SETUP = VUE_SETUP_HOOK_NAMES.map(name => `export const ${name} = undefined`).join('\n');
+// `logEvent` from `poveste/client` reaches `@poveste/app`, which names these. A
+// test never runs the code that reads them, but Vite's dependency scan follows
+// the imports, and one it can't resolve skips pre-bundling and reloads the
+// browser run partway through.
+const INERT = {
+    [VIRTUAL_IDS.markdownFiles]: 'export const markdownFiles = []\n',
+    [VIRTUAL_IDS.componentDocs]: 'export const componentDocs = {}\n',
+    [VIRTUAL_IDS.supportPluginsClient]: 'export const clientSupportPlugins = {}\n',
+};
+// Nuxt boots in `@nuxt/test-utils`' `beforeAll`, after Vitest has collected the
+// tests, and a story's own setup can call a Nuxt composable while it is being
+// collected. So its own `setupNuxt` runs before collection, into the promise that
+// `beforeAll` awaits, and Nuxt boots once and in full. Both names are internal to
+// `@nuxt/test-utils`: if a version renames them, the story tests fail loudly.
+function nuxtEnvironment(setupNuxt) {
+    return `import { tryUseNuxtApp } from '#app/nuxt'
+import { setupNuxt } from ${JSON.stringify(setupNuxt)}
+
+export async function environmentReady() {
+  const win = window
+  if (!win.__NUXT_VITEST_ENVIRONMENT__ || tryUseNuxtApp()) {
+    return
+  }
+  win.__NUXT_VITEST_ENVIRONMENT_PROMISE__ ??= setupNuxt()
+  await win.__NUXT_VITEST_ENVIRONMENT_PROMISE__
+}
+
+export function environmentApp() {
+  return tryUseNuxtApp()?.vueApp
+}
+`;
+}
+const NO_ENVIRONMENT = `export async function environmentReady() {}\nexport function environmentApp() {\n  return undefined\n}\n`;
+// `@nuxt/test-utils`' own boot, by file: its `exports` don't list it.
+function setupNuxtFile(root) {
+    try {
+        const file = join(dirname(createRequire(join(root, 'package.json')).resolve('@nuxt/test-utils/package.json')), 'dist/runtime/shared/nuxt.mjs');
+        return existsSync(file) ? file : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Root-relative, as `poveste dev` reads it: the docs write `/src/poveste.setup.ts`,
+// which `resolve` takes as absolute, so pre-bundling scanned a file outside the
+// book and the setup file's imports were found late, with a reload (#1507).
+function setupFileOf(config) {
+    const setupFile = config.setupFile;
+    const file = typeof setupFile === 'string' ? setupFile : setupFile && 'browser' in setupFile ? setupFile.browser : undefined;
+    return file?.replace(/^\/+/, '');
+}
+/**
+ * What a story needs in the user's own Vitest to render as `poveste dev` renders
+ * it: the book's setup file and the modules Poveste's client imports, with
+ * Poveste's own packages inlined so Vitest can serve those, and `vue` and the
+ * setup file pre-bundled for browser mode. Nothing else: no alias and no change
+ * to how anything resolves, so the test sees the project's Vite config as the
+ * project wrote it.
+ *
+ * Setup code that a plugin generates for `poveste dev`, such as the Nuxt app
+ * `@poveste/plugin-nuxt` boots, is left to the test environment, which already
+ * provides it: `@nuxt/test-utils`'s `nuxt` environment does in a Nuxt project.
+ */
+export function povesteTesting(options = {}) {
+    let root = process.cwd();
+    let config = {};
+    return {
+        name: 'poveste:testing',
+        async config(user) {
+            root = resolve(user.root ?? process.cwd());
+            const file = options.configFile ? resolve(root, options.configFile) : resolveConfigFile(root);
+            const fromFile = file ? await loadConfigFile(file) : {};
+            // As `poveste dev` reads it: the config file, then the Vite config's key.
+            const fromVite = (user.poveste
+                ?? user.histoire ?? {});
+            config = mergeConfig(fromFile, fromVite);
+            // In browser mode Vite pre-bundles what its scan finds. It never sees `vue`,
+            // which compiled templates and this package's own bundle import, nor the
+            // setup file, which arrives as a virtual module. Each was bundled later,
+            // with a reload partway through the first run, and two copies of Vue
+            // failed it (#1503).
+            const setupFile = setupFileOf(config);
+            const optimizeDeps = {
+                include: ['vue'],
+                ...setupFile ? { entries: [relative(root, resolve(root, setupFile)).split(sep).join('/')] } : {},
+            };
+            // `true` already inlines everything, and an array merged into it would not.
+            if (user.test?.server?.deps?.inline === true) {
+                return { optimizeDeps };
+            }
+            return { optimizeDeps, test: { server: { deps: { inline: POVESTE_PACKAGES } } } };
+        },
+        configResolved(resolved) {
+            root = resolved.root;
+        },
+        async resolveId(id, importer) {
+            if (id === VIRTUAL_IDS.setup) {
+                const file = setupFileOf(config);
+                if (file) {
+                    return this.resolve(resolve(root, file), importer, { skipSelf: true });
+                }
+                return EMPTY_SETUP_ID;
+            }
+            if (id === VIRTUAL_IDS.generatedGlobalSetup) {
+                return EMPTY_SETUP_ID;
+            }
+            if (id === VIRTUAL_IDS.config) {
+                return CONFIG_RESOLVED_ID;
+            }
+            if (id === VAPOR_INTEROP_ID) {
+                return `\0${VAPOR_INTEROP_ID}`;
+            }
+            if (Object.hasOwn(INERT, id)) {
+                return `\0${id}`;
+            }
+            if (id === ENVIRONMENT_ID) {
+                return `\0${ENVIRONMENT_ID}`;
+            }
+            return undefined;
+        },
+        // A story's `<docs>` block, which `poveste dev` renders as markdown. A test
+        // renders the variants, not the docs, so it only has to import.
+        transform(_code, id) {
+            if (id.includes('?vue&type=docs')) {
+                return 'export default () => {}';
+            }
+            return undefined;
+        },
+        async load(id) {
+            if (id === EMPTY_SETUP_ID) {
+                return EMPTY_SETUP;
+            }
+            if (id === CONFIG_RESOLVED_ID) {
+                return `export const config = ${JSON.stringify(clientConfig({ ...getDefaultConfig(), ...config }))}\nexport const logos = {}\n`;
+            }
+            if (id === `\0${VAPOR_INTEROP_ID}`) {
+                return vaporInteropModule(projectVueVersion(root));
+            }
+            if (id.startsWith('\0') && Object.hasOwn(INERT, id.slice(1))) {
+                return INERT[id.slice(1)];
+            }
+            // The app the test environment boots: Nuxt's, under `@nuxt/test-utils`' `nuxt`
+            // environment. `poveste dev` renders a story inside the Nuxt app its plugin
+            // boots, and a test does the same. Told by Nuxt's own `#app` alias and the
+            // test utils being installed, not by `#imports`, which unimport also serves.
+            if (id === `\0${ENVIRONMENT_ID}`) {
+                const setupNuxt = setupNuxtFile(root);
+                return setupNuxt && await this.resolve('#app/nuxt', resolve(root, 'index.html'))
+                    ? nuxtEnvironment(setupNuxt)
+                    : NO_ENVIRONMENT;
+            }
+            return undefined;
+        },
+    };
+}

package/dist/util/project-vue.d.ts

@@ -0,0 +1 @@
+export declare function projectVueVersion(root: string): string | undefined;