@poveste/plugin-vue 0.19.1 → 0.21.0

package/dist/bundled/client/server/run.js

@@ -1,44 +1,15 @@
-import { VUE_SETUP_HOOK_NAMES as e } from "../../setup-hooks.js";
-import { addStoryContext as t, storyFileContext as n } from "./context.js";
-import r from "./Story.js";
-import i from "./Variant.js";
-import { createApp as a, h as o } from "vue";
-import { getSetupHook as s } from "@poveste/shared";
-import * as c from "virtual:$poveste-generated-global-setup";
-import * as l from "virtual:$poveste-setup";
+import { collectComponent as e } from "./collect.js";
 //#region src/client/server/run.ts
-async function u({ file: u, storyData: d, el: f }) {
-	let { default: p } = await import(/* @vite-ignore */
+async function t({ file: t, storyData: n, el: r }) {
+	let { default: i } = await import(/* @vite-ignore */
 		/* @vite-ignore */
-		u.moduleId
-	), m = a({
-		setup() {
-			t.provide((e) => {
-				d.push(e);
-			}), n.provide(u);
-		},
-		render() {
-			return o(p);
-		}
+		t.moduleId
+	);
+	await e(i, {
+		file: t,
+		storyData: n,
+		el: r
 	});
-	m.component("Story", r), m.component("Variant", i);
-	let h = {
-		app: m,
-		story: void 0,
-		variant: void 0,
-		addWrapper: () => {}
-	}, g = s(c, e);
-	g && await g(h);
-	let _ = s(l, e);
-	if (_ && await _(h), m.mount(f), p.doc) {
-		let e = document.createElement("div");
-		e.innerHTML = p.doc;
-		let t = e.textContent;
-		d.forEach((e) => {
-			e.docsText = t;
-		});
-	}
-	m.unmount();
 }
 //#endregion
-export { u as run };
+export { t as run };

package/dist/bundled/client/server.js

@@ -1,2 +1 @@
-import { run as e } from "./server/run.js";
-export { e as run };
+export { run } from "./server/run.js";

package/dist/bundled/testing/index.js

@@ -0,0 +1,168 @@
+import { syncStateBundledAndExternal as e } from "../client/app/util.js";
+import { registerControlComponents as t } from "../client/app/global-components.js";
+import { createPreviewHost as n } from "../client/app/host.js";
+import { collectComponent as r } from "../client/server/collect.js";
+import { markRaw as i, nextTick as a, reactive as o } from "vue";
+import { environmentApp as s, environmentReady as c } from "virtual:$poveste-testing-environment";
+import { describe as l, it as u } from "vitest";
+//#region src/testing/index.ts
+function d(e, t = {}) {
+	let n = t.name ?? x(e.__file) ?? "stories", r = t.timeout ?? 5e3;
+	l(n, async () => {
+		await c();
+		let { stories: t, problems: i } = await f(e, n);
+		if (i.length || !t.length) u("collects", () => {
+			throw y(`collecting ${n}`, i.length ? i : ["it has no <Story>"]);
+		});
+		else for (let e of t) l(e.title, () => {
+			for (let t of e.variants) u(t.title, async () => {
+				let n = await m(e, t, r);
+				if (n.length) throw y(`${e.title} › ${t.title}`, n);
+			});
+		});
+	});
+}
+async function f(e, t) {
+	let n = e.__file ?? t, a = x(n) ?? t, o = {
+		id: t.replace(/\W+/g, "-").toLowerCase(),
+		path: n,
+		moduleId: n,
+		fileName: a.includes(".") ? a.slice(0, a.indexOf(".")) : a
+	}, s = [], c = [], l = document.createElement("div");
+	try {
+		await r(e, {
+			file: o,
+			storyData: s,
+			el: l
+		}, {
+			beforeSetup(e) {
+				e.config.errorHandler = (e) => {
+					c.push(e);
+				}, e.config.warnHandler = (e, t, n) => {
+					c.push(b(e, n));
+				};
+			},
+			afterSetup(e) {
+				_(e._context.components, h()), g(e);
+			}
+		});
+	} catch (e) {
+		c.push(e);
+	}
+	let u = {
+		id: o.id,
+		supportPluginId: "vue3",
+		component: i(e),
+		path: [],
+		filePath: o.path,
+		source: async () => ({ default: "" })
+	};
+	return {
+		stories: s.map((e) => {
+			let t = {
+				...e,
+				file: i(u),
+				variants: e.variants.map((e) => p(e)),
+				slots: () => ({})
+			};
+			return u.story = t, t;
+		}),
+		problems: c
+	};
+}
+function p(e) {
+	return {
+		...e,
+		state: o({
+			_hPropState: {},
+			_hPropDefs: {}
+		}),
+		setupApp: void 0,
+		slots: () => ({}),
+		previewReady: !1
+	};
+}
+async function m(t, r, i) {
+	let a = [], s = (e) => {
+		a.push(e);
+	}, c = (e, t) => {
+		a.push(b(e, t));
+	}, l = !1, u = document.createElement("div");
+	document.body.appendChild(u);
+	let d = n({
+		name: "StoryTestMount",
+		el: u,
+		getStory: () => t,
+		getVariant: () => null,
+		renderContext: o({
+			mode: "mount",
+			slotName: "default",
+			currentVariant: null,
+			targetVariantId: r.id,
+			externalState: null,
+			nextVariantIndex: { value: 0 }
+		}),
+		onError: s,
+		onWarn: c,
+		configureApp: g
+	}), f = o({}), p = e(r.state, f), m = n({
+		name: "StoryTestRender",
+		el: u,
+		getStory: () => t,
+		getVariant: () => r,
+		renderContext: o({
+			mode: "render",
+			slotName: "default",
+			currentVariant: r,
+			externalState: f,
+			nextVariantIndex: { value: 0 }
+		}),
+		wrapInDiv: !0,
+		onError: s,
+		onWarn: c,
+		onResolve: () => {
+			l = !0;
+		},
+		configureApp: g
+	});
+	try {
+		await d.mount(), await v(() => !!r.configReady || a.length > 0, i) || a.push(/* @__PURE__ */ Error(`its setup did not settle within ${i} ms`)), a.length || (await m.mount(), await v(() => l || a.length > 0, i) || a.push(/* @__PURE__ */ Error(`its render did not settle within ${i} ms`)));
+	} catch (e) {
+		a.push(e);
+	} finally {
+		m.unmount(), d.unmount(), p.stop(), u.remove();
+	}
+	return a;
+}
+function h() {
+	let e = {};
+	return t({ component: (t, n) => {
+		e[t] = n;
+	} }), e;
+}
+function g(e) {
+	let t = s();
+	t && (_(e, t), _(e._context.provides, t._context.provides), _(e.config.globalProperties, t.config.globalProperties), _(e._context.components, t._context.components), _(e._context.directives, t._context.directives));
+}
+function _(e, t) {
+	for (let n of Reflect.ownKeys(t)) n in e || Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+}
+async function v(e, t) {
+	let n = Date.now() + t;
+	do
+		if (await a(), await new Promise((e) => setTimeout(e)), e()) return !0;
+	while (Date.now() < n);
+	return e();
+}
+function y(e, t) {
+	let n = t[0], r = t.map((e) => e instanceof Error ? e.stack ?? e.message : String(e)), i = /* @__PURE__ */ Error(`${e}: ${t.length === 1 ? "one problem" : `${t.length} problems`}\n\n${r.join("\n\n")}`);
+	return n instanceof Error && (i.cause = n), i;
+}
+function b(e, t) {
+	return `[Vue warn]: ${e}${t ? `\n${t}` : ""}`;
+}
+function x(e) {
+	return e?.split(/[\\/]/).pop();
+}
+//#endregion
+export { d as testStories };

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

@@ -1,5 +1,5 @@
 import type { Story } from '@poveste/shared';
-import type { PropType, VNode } from 'vue';
+import type { Component, PropType, VNode } from 'vue';
 import type { PreviewRenderContext } from './render-context.js';
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     initState: {
@@ -10,6 +10,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<Story["meta"]>;
         default: undefined;
     };
+    autoDocs: {
+        type: PropType<Story["autoDocs"]>;
+        default: undefined;
+    };
+    component: {
+        type: PropType<Component | Component[]>;
+        default: undefined;
+    };
 }>, {
     renderContext: PreviewRenderContext | null;
     story: import("vue").ComputedRef<Story>;
@@ -29,8 +37,18 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<Story["meta"]>;
         default: undefined;
     };
+    autoDocs: {
+        type: PropType<Story["autoDocs"]>;
+        default: undefined;
+    };
+    component: {
+        type: PropType<Component | Component[]>;
+        default: undefined;
+    };
 }>> & Readonly<{}>, {
+    component: Component | Component[];
     meta: import("poveste").StoryMeta | undefined;
+    autoDocs: boolean | import("poveste").AutoDocsSection[] | undefined;
     initState: () => any | Promise<any>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/client/app/Variant.d.ts

@@ -69,11 +69,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>> & Readonly<{}>, {
     meta: import("poveste").VariantMeta | undefined;
-    initState: () => any | Promise<any>;
+    setupApp: Function;
     source: string;
     responsiveDisabled: boolean;
     autoPropsDisabled: boolean;
-    setupApp: Function;
+    initState: () => any | Promise<any>;
     implicit: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/client/app/global-components.d.ts

@@ -1,2 +1,3 @@
 import type { App } from 'vue';
 export declare function registerGlobalComponents(app: App): void;
+export declare function registerControlComponents(app: App): void;

package/dist/client/app/host.d.ts

@@ -1,4 +1,5 @@
 import type { Story, Variant } from '@poveste/shared';
+import type { App } from 'vue';
 import type { PreviewRenderContext } from './render-context.js';
 interface PreviewHostOptions {
     name: string;
@@ -7,6 +8,13 @@ interface PreviewHostOptions {
     getVariant: () => Variant | null;
     renderContext: PreviewRenderContext;
     wrapInDiv?: boolean;
+    /** A story test's: what the app would only log, it fails on. */
+    onError?: (err: unknown) => void;
+    onWarn?: (message: string, trace: string) => void;
+    /** A story test's: when the render's async setups have settled. */
+    onResolve?: () => void;
+    /** A story test's, run after the app's own registrations and setup hooks. */
+    configureApp?: (app: App) => void;
 }
 export declare function createPreviewHost(options: PreviewHostOptions): {
     mount: () => Promise<void>;

package/dist/client/app/util.d.ts

@@ -49,4 +49,32 @@ export declare function syncStateBundledAndExternal(bundledState: Record<string,
  * it appeared in the panel and warned when written.
  */
 export declare function isWritableBinding(value: unknown): boolean;
+/**
+ * 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 declare function isComponentBinding(value: unknown): boolean;
+/**
+ * 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 declare function holdsVueApp(value: unknown): boolean;
 export declare function useInstance(name: string): ComponentInternalInstance;
+/**
+ * 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 declare function warnIfForeignVue(component: string): void;
+/** For specs: lets the warning be seen again. */
+export declare function resetForeignVueWarning(): void;

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

@@ -0,0 +1,7 @@
+import type { DocgenExtractor, DocgenExtractorContext } from '@poveste/shared';
+/**
+ * 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 declare function createExtractor(context: DocgenExtractorContext): Promise<DocgenExtractor>;

package/dist/docgen/extractor.js

@@ -0,0 +1,60 @@
+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) {
+    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) {
+            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/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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,76 @@
+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));
+}
+function isInherited(prop, allow) {
+    return declaredOnlyInPackages(prop.getDeclarations().map(declaration => declaration.file), allow);
+}
+function toProp(prop) {
+    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) {
+    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) {
+    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(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 {};