@poveste/plugin-vue 0.19.1 → 0.21.0

package/src/client/app/util.ts

@@ -1,6 +1,7 @@
 import type { ComponentInternalInstance } from 'vue'
 import { applyState, createStateBaseline, isMarkedRaw, isPlainObject } from '@poveste/shared'
 import {
+  getCurrentInstance as _getCurrentInstance,
   isRef as _isRef,
   unref as _unref,
   watch as _watch,
@@ -234,6 +235,46 @@ export function isWritableBinding(value: unknown): boolean {
   return !(isRef(value) && isReadonly(value))
 }
 
+/**
+ * A component a story holds in its setup, which implicit state skips.
+ *
+ * Each key is asked with `in` before it is read. Nuxt's runtime config is, in
+ * dev, a proxy that warns on any key it does not carry, and reading `__file`,
+ * `render` and `setup` off it printed `NUXT_E1003` three times a mount (#1454).
+ */
+export function isComponentBinding(value: unknown): boolean {
+  if (typeof value === 'function') {
+    return true
+  }
+  if (!isObject(value)) {
+    return false
+  }
+  return ('__file' in value && !!value.__file)
+    || ('render' in value && typeof value.render === 'function')
+    || ('setup' in value && typeof value.setup === 'function')
+}
+
+function isVueApp(value: unknown): boolean {
+  return isObject(value) && '_context' in value && '_component' in value && 'mount' in value
+}
+
+/**
+ * A Vue app, or an object holding one in a data property of its own, as the
+ * Nuxt app `useNuxtApp()` returns does. Implicit state skips it: the state sync
+ * deep-watches what it holds, so it walked the whole app on every sync, as far
+ * as the dev-only `app.config.compilerOptions` getter that warns when read
+ * (#1457). Read through descriptors, so no getter runs to find out.
+ */
+export function holdsVueApp(value: unknown): boolean {
+  if (!isObject(value)) {
+    return false
+  }
+  if (isVueApp(value)) {
+    return true
+  }
+  return Object.values(Object.getOwnPropertyDescriptors(value)).some(descriptor => 'value' in descriptor && isVueApp(descriptor.value))
+}
+
 export function useInstance(name: string): ComponentInternalInstance {
   const vm = getCurrentInstance()
   if (!vm) {
@@ -241,3 +282,27 @@ export function useInstance(name: string): ComponentInternalInstance {
   }
   return vm
 }
+
+let warnedForeignVue = false
+
+/**
+ * Warns, once, when a component built against `@poveste/vendors/vue` is
+ * rendered by another copy of Vue.
+ *
+ * The other copy runs the component's `setup`, so the vendored one has no
+ * current instance and drops every hook: the story renders nothing, and no build
+ * of Vue says why. A test mounting `MountStory` with `createApp` from `vue` read
+ * it as a story with no variants (#940).
+ */
+export function warnIfForeignVue(component: string) {
+  if (warnedForeignVue || _getCurrentInstance()) {
+    return
+  }
+  warnedForeignVue = true
+  console.warn(`[poveste] ${component} was rendered by a copy of Vue other than \`@poveste/vendors/vue\`, so it renders nothing. Poveste's client components are built against that copy: create the app with \`createApp\` from \`@poveste/vendors/vue\`, not from \`vue\`.`)
+}
+
+/** For specs: lets the warning be seen again. */
+export function resetForeignVueWarning() {
+  warnedForeignVue = false
+}

package/src/client/server/Story.ts

@@ -1,5 +1,5 @@
-import type { ServerStory, ServerVariant } from '@poveste/shared'
-import type { PropType } from 'vue'
+import type { AutoDocsSection, ServerStory, ServerVariant } from '@poveste/shared'
+import type { Component, PropType } from 'vue'
 import { defineComponent, onMounted } from 'vue'
 import { addStoryContext, addVariantContext, serverStoryContext, storyFileContext } from './context.js'
 import { autoStubComponents } from './stub.js'
@@ -45,6 +45,18 @@ export default defineComponent({
       default: false,
     },
 
+    // A default, so an absent prop stays `undefined` rather than Vue's `false` for a Boolean.
+    autoDocs: {
+      type: [Boolean, Array] as PropType<boolean | AutoDocsSection[]>,
+      default: undefined,
+    },
+
+    // Read from the source by auto-docs, not at collection (#1432).
+    component: {
+      type: [Object, Function, Array] as PropType<Component | Component[]>,
+      default: undefined,
+    },
+
     meta: {
       type: Object as PropType<ServerStory['meta']>,
       default: undefined,
@@ -70,6 +82,7 @@ export default defineComponent({
       icon: props.icon,
       iconColor: props.iconColor,
       docsOnly: props.docsOnly,
+      ...props.autoDocs !== undefined ? { autoDocs: props.autoDocs } : {},
       meta: props.meta,
       variants: [],
     }

package/src/client/server/collect.ts

@@ -0,0 +1,83 @@
+import type { ServerRunPayload, ServerStory } from '@poveste/shared'
+import type { App, Component } from 'vue'
+import type { Vue3StorySetupApi, Vue3StorySetupHandler } from '../../helpers.js'
+import { getSetupHook } from '@poveste/shared'
+// @ts-expect-error virtual module id
+import * as generatedSetup from 'virtual:$poveste-generated-global-setup'
+// @ts-expect-error virtual module id
+import * as setup from 'virtual:$poveste-setup'
+import { createApp, h } from 'vue'
+import { VUE_SETUP_HOOK_NAMES } from '../../setup-hooks.js'
+import { addStoryContext, storyFileContext } from './context.js'
+import Story from './Story.js'
+import Variant from './Variant.js'
+
+/**
+ * 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 async 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
+  } = {},
+) {
+  const app = createApp({
+    // Provided from `setup` rather than the options object so the keys can be
+    // the symbols the components inject; the options form takes string keys.
+    setup() {
+      addStoryContext.provide((data: ServerStory) => {
+        storyData.push(data)
+      })
+      storyFileContext.provide(file)
+    },
+    render() {
+      return h(Comp)
+    },
+  })
+
+  app.component('Story', Story)
+
+  app.component('Variant', Variant)
+
+  hooks.beforeSetup?.(app)
+
+  // Call app setups to resolve global assets such as components
+
+  const setupApi: Vue3StorySetupApi = {
+    app,
+    // No story or variant exists while collecting.
+    story: undefined,
+    variant: undefined,
+    addWrapper: () => { /* noop */ },
+  }
+
+  const generatedSetupFn = getSetupHook<Vue3StorySetupHandler>(generatedSetup, VUE_SETUP_HOOK_NAMES)
+  if (generatedSetupFn) {
+    await generatedSetupFn(setupApi)
+  }
+
+  const setupFn = getSetupHook<Vue3StorySetupHandler>(setup, VUE_SETUP_HOOK_NAMES)
+  if (setupFn) {
+    await setupFn(setupApi)
+  }
+
+  hooks.afterSetup?.(app)
+
+  app.mount(el)
+
+  if (Comp.doc) {
+    const el = document.createElement('div')
+    el.innerHTML = Comp.doc
+    const text = el.textContent
+    storyData.forEach((s) => {
+      s.docsText = text
+    })
+  }
+
+  app.unmount()
+}

package/src/client/server/run.ts

@@ -1,67 +1,7 @@
-import type { ServerRunPayload, ServerStory } from '@poveste/shared'
-import type { Vue3StorySetupApi, Vue3StorySetupHandler } from '../../helpers.js'
-import { getSetupHook } from '@poveste/shared'
-// @ts-expect-error virtual module id
-import * as generatedSetup from 'virtual:$poveste-generated-global-setup'
-// @ts-expect-error virtual module id
-import * as setup from 'virtual:$poveste-setup'
-import { createApp, h } from 'vue'
-import { VUE_SETUP_HOOK_NAMES } from '../../setup-hooks.js'
-import { addStoryContext, storyFileContext } from './context.js'
-import Story from './Story.js'
-import Variant from './Variant.js'
+import type { ServerRunPayload } from '@poveste/shared'
+import { collectComponent } from './collect.js'
 
 export async function run({ file, storyData, el }: ServerRunPayload) {
   const { default: Comp } = await import(/* @vite-ignore */ file.moduleId)
-
-  const app = createApp({
-    // Provided from `setup` rather than the options object so the keys can be
-    // the symbols the components inject; the options form takes string keys.
-    setup() {
-      addStoryContext.provide((data: ServerStory) => {
-        storyData.push(data)
-      })
-      storyFileContext.provide(file)
-    },
-    render() {
-      return h(Comp)
-    },
-  })
-
-  app.component('Story', Story)
-
-  app.component('Variant', Variant)
-
-  // Call app setups to resolve global assets such as components
-
-  const setupApi: Vue3StorySetupApi = {
-    app,
-    // No story or variant exists while collecting.
-    story: undefined,
-    variant: undefined,
-    addWrapper: () => { /* noop */ },
-  }
-
-  const generatedSetupFn = getSetupHook<Vue3StorySetupHandler>(generatedSetup, VUE_SETUP_HOOK_NAMES)
-  if (generatedSetupFn) {
-    await generatedSetupFn(setupApi)
-  }
-
-  const setupFn = getSetupHook<Vue3StorySetupHandler>(setup, VUE_SETUP_HOOK_NAMES)
-  if (setupFn) {
-    await setupFn(setupApi)
-  }
-
-  app.mount(el)
-
-  if (Comp.doc) {
-    const el = document.createElement('div')
-    el.innerHTML = Comp.doc
-    const text = el.textContent
-    storyData.forEach((s) => {
-      s.docsText = text
-    })
-  }
-
-  app.unmount()
+  await collectComponent(Comp, { file, storyData, el })
 }

package/src/client-dependencies.ts

@@ -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/src/docgen/events.ts

@@ -0,0 +1,55 @@
+import type ts from 'typescript'
+
+export interface EventDoc {
+  description: string
+  tags: { name: string, text?: string }[]
+}
+
+/*
+ * 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: typeof ts, node: ts.Node): ts.TypeAliasDeclaration | undefined {
+  if (typescript.isTypeAliasDeclaration(node) && node.name.text === '__VLS_Emit') {
+    return node
+  }
+  return typescript.forEachChild(node, child => findEmitAlias(typescript, child))
+}
+
+export function readEventDocs(typescript: typeof ts, program: ts.Program | undefined, file: string): Map<string, EventDoc> {
+  const docs = new Map<string, EventDoc>()
+  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: ts.JSDocTagInfo[]) => 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/src/docgen/extractor.ts

@@ -0,0 +1,67 @@
+import type { DocgenExtractor, DocgenExtractorContext } from '@poveste/shared'
+import type ts from 'typescript'
+import type { VueDocgenOptions } from './meta.js'
+import { existsSync, readFileSync } from 'node:fs'
+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'
+import { readSlotProps } from './slots.js'
+
+const SOURCE = /\.(?:vue|[cm]?[jt]sx?)$/
+
+/**
+ * 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: DocgenExtractorContext): Promise<DocgenExtractor> {
+  const { createChecker, createCheckerByJson, TypeMeta } = await import('vue-component-meta')
+  const options = (context.options ?? {}) as VueDocgenOptions
+  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: typeof ts = 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: string) {
+    try {
+      const meta = checker.getComponentMeta(file, 'default')
+      return meta.type === TypeMeta.Unknown ? undefined : meta
+    }
+    catch {
+      return undefined
+    }
+  }
+
+  return {
+    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
+      }
+      if (existsSync(file)) {
+        checker.updateFile(file, readFileSync(file, 'utf8'))
+      }
+      else {
+        checker.deleteFile(file)
+      }
+    },
+    sources: () => checker.getProgram()?.getSourceFiles().map(sourceFile => sourceFile.fileName).filter(file => !file.includes('/node_modules/')) ?? [],
+    // The program is released with the checker; this drops what it cached.
+    dispose: () => checker.clearCache(),
+  }
+}

package/src/docgen/generic.ts

@@ -0,0 +1,20 @@
+// 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: string): string | undefined {
+  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/src/docgen/meta.ts

@@ -0,0 +1,93 @@
+import type { ComponentDoc, DocEvent, DocProp, DocSlot, DocTag } from '@poveste/shared'
+import type { DocgenOptions } from 'poveste/docgen'
+import type { ComponentMeta, EventMeta, PropertyMeta, SlotMeta } from 'vue-component-meta'
+import type { EventDoc } from './events.js'
+import { declaredOnlyInPackages, DEFAULT_TAGS, HIDDEN_TAGS, normalizeDefault } from 'poveste/docgen'
+
+export type VueDocgenOptions = DocgenOptions
+
+type Tags = { name: string, text?: string }[]
+
+function tagsOf(tags: Tags): DocTag[] {
+  return tags.map(({ name, text }) => text === undefined ? { name } : { name, text })
+}
+
+function isHidden(tags: Tags) {
+  return tags.some(tag => HIDDEN_TAGS.includes(tag.name))
+}
+
+function isInherited(prop: PropertyMeta, allow: string[]) {
+  return declaredOnlyInPackages(prop.getDeclarations().map(declaration => declaration.file), allow)
+}
+
+function toProp(prop: PropertyMeta): DocProp {
+  const defaultTag = prop.tags.find(tag => DEFAULT_TAGS.includes(tag.name))?.text
+  return {
+    name: prop.name,
+    ...prop.description ? { description: prop.description } : {},
+    type: prop.type,
+    required: prop.required,
+    ...prop.default !== undefined ? { default: prop.default } : {},
+    ...defaultTag !== undefined ? { defaultTag } : {},
+    // The code's default is what runs, so it is the one shown; the flag is for the reader.
+    ...prop.default !== undefined && defaultTag !== undefined && normalizeDefault(prop.default) !== normalizeDefault(defaultTag)
+      ? { defaultConflict: true }
+      : {},
+    tags: tagsOf(prop.tags),
+  }
+}
+
+function toMember(member: Pick<SlotMeta | EventMeta, 'name' | 'description' | 'type' | 'tags'>): DocSlot & DocEvent {
+  return {
+    name: member.name,
+    ...member.description ? { description: member.description } : {},
+    ...member.type ? { type: member.type } : {},
+    tags: tagsOf(member.tags),
+  }
+}
+
+/**
+ * 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: string): string {
+  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: EventMeta, doc: EventDoc | undefined): Pick<EventMeta, 'name' | 'description' | 'type' | 'tags'> {
+  return {
+    name: event.name,
+    description: event.description || doc?.description || '',
+    type: asParameters(event.type),
+    tags: event.tags.length ? event.tags : doc?.tags ?? [],
+  }
+}
+
+function toSlot(slot: SlotMeta, slotProps: (slot: SlotMeta) => DocSlot['props'] & {}): DocSlot {
+  const props = slotProps(slot)
+  return { ...toMember(slot), ...props.length ? { props } : {} }
+}
+
+export function toComponentDoc(meta: ComponentMeta, options: VueDocgenOptions = {}, eventDocs = new Map<string, EventDoc>(), slotProps: (slot: SlotMeta) => DocSlot['props'] & {} = () => []): ComponentDoc {
+  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(slot => toSlot(slot, slotProps)),
+    events: meta.events.map(event => withDocs(event, eventDocs.get(event.name))).filter(event => !isHidden(event.tags)).map(toMember),
+  }
+}

package/src/docgen/slots.ts

@@ -0,0 +1,33 @@
+import type { DocSlot } from '@poveste/shared'
+import type ts from 'typescript'
+import type { SlotMeta } from 'vue-component-meta'
+
+/*
+ * vue-component-meta gives a slot's props as one type string, `{ open: boolean; close:
+ * () => void; }`, with the JSDoc on each of them lost inside it, and reka-ui writes its
+ * slot documentation there and nowhere else (#1436). The slot's type object resolves
+ * through the same program, one property each.
+ */
+type DocSlotProp = NonNullable<DocSlot['props']>[number]
+
+export function readSlotProps(typescript: typeof ts, program: ts.Program | undefined, slot: SlotMeta): DocSlotProp[] {
+  if (!program) {
+    return []
+  }
+  const checker = program.getTypeChecker()
+  let type: ts.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/src/index.node.ts

@@ -1,13 +1,17 @@
 import type { Plugin } from 'poveste'
 
-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 { 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(): Plugin {
   return {
@@ -28,7 +32,16 @@ export function HstVue(): Plugin {
     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(),
             (() => {
               let root = process.cwd()
@@ -59,6 +72,16 @@ export function HstVue(): Plugin {
       }
     },
 
+    // 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') || SCRIPT_COMPONENT.test(file)) && !/\.story\.[^/]+$/.test(file) && !file.includes('/node_modules/'),
+      module: fileURLToPath(new URL('./docgen/extractor.js', import.meta.url)),
+      // `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',
       moduleName: '@poveste/plugin-vue',
@@ -82,14 +105,6 @@ export function HstVue(): Plugin {
   }
 }
 
-function projectVueVersion(root: string): string | undefined {
-  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'
+export type { PovesteTestingOptions } from './testing/vite.js'