poveste 0.20.0 → 0.21.0

package/README.md

@@ -5,9 +5,14 @@
 Poveste builds a browsable *book* of stories from your components, powered by
 [Vite](https://vite.dev). It is a drop-in fork of
 [histoire](https://github.com/histoire-dev/histoire), covering Vue, Nuxt, Svelte,
-SvelteKit and Quasar — the last of which histoire does not support. Solid and React
-are supported as renderers only: their stories render, and they have no controls
-panel.
+SvelteKit and Quasar — the last of which no released version of histoire includes — and
+Solid and React, whose stories render with no controls panel yet.
+
+In every one of those books, each story's **Docs** tab also shows a props, slots and
+events table read from its components' types: the ones a Vue or Svelte story imports, or
+the one a Solid or React story names in its `component` field. That needs `typescript` 6
+or earlier in the book, plus `svelte2tsx` in a Svelte book and `@types/react` in a React
+one.
 
 <img src="https://raw.githubusercontent.com/poveste-dev/poveste/main/screenshot.png" alt="A poveste book: the story list, a variant grid, and the controls panel" width="900">
 
@@ -20,11 +25,11 @@ pnpm i -D poveste @poveste/plugin-vue                          # Vue 3
 pnpm i -D poveste @poveste/plugin-svelte                       # Svelte 5 and SvelteKit
 pnpm i -D poveste @poveste/plugin-vue @poveste/plugin-nuxt     # Nuxt 4
 pnpm i -D poveste @poveste/plugin-vue @poveste/plugin-quasar   # Quasar
-pnpm i -D poveste @poveste/plugin-solid                        # Solid, renderer only
-pnpm i -D poveste @poveste/plugin-react                        # React 19, renderer only
+pnpm i -D poveste @poveste/plugin-solid                        # Solid, no controls yet
+pnpm i -D poveste @poveste/plugin-react                        # React 19, no controls yet
 ```
 
-> **Installed an older version than you expected?** For about a day after a release, pnpm installs the previous one with no error and no hint, and for a plugin that's new in that release, its empty `0.0.1` placeholder. That's pnpm's release-age cooldown, not a broken publish. `package.json` keeps the old `^x.y.z`, so waiting doesn't fix it: install again with `npm`, with `--config.minimum-release-age=0` (kebab-case: pnpm 12.4 ignores the camelCase spelling), or with exact versions.
+> **Installed an older version than you expected?** For about a day after a release, pnpm installs the previous one with no error, and for a plugin that's new in that release, its empty `0.0.1` placeholder. pnpm 11.5.3 added `(x.y.z is available)` after the version it installed; pnpm 12.14.0 said nothing. That's pnpm's release-age cooldown, not a broken publish. `package.json` keeps the old `^x.y.z`, so waiting doesn't fix it: install again with `npm`, with `--config.minimum-release-age=0` (kebab-case: pnpm 12.4.0 ignores the camelCase spelling, which 12.14.0 accepts), or with exact versions.
 
 Then create a `poveste.config.ts` in your project root. For a Vue project it is this:
 
@@ -57,7 +62,9 @@ Node `>=22.22.2` and Vite `^8.0.0`. See
 [supported versions](https://poveste.dev/guide/getting-started#supported-versions) for
 what proves each range.
 
-On Node 24, use 24.15 or later: Poveste's DOM dependency (jsdom) accepts `^22.22.2 || ^24.15.0 || >=26`.
+On Node 24, prefer 24.15 or later. Poveste's DOM dependency, jsdom, and three of its own dependencies declare `^22.22.2 || ^24.15.0 || >=26`. On 24.13.0 npm warns `EBADENGINE` for each of them and installs anyway, and a Vue book built there, but nothing tests Poveste on a Node 24 before 24.15.
+
+Auto-docs, the props, slots and events table in Vue, Nuxt, Quasar, Svelte, SvelteKit, Solid and React books, needs `typescript` 6 or earlier in the book: `npm i -D typescript@6`. A Svelte or SvelteKit book also needs `svelte2tsx`, and a React book `@types/react`. Without them, or with TypeScript 7, it turns itself off and says so once. See [`autoDocs`](https://poveste.dev/reference/config#autodocs).
 
 ## Links
 

package/dist/node/build.js

@@ -124,7 +124,7 @@ export async function build(ctx) {
             // Same wrapper the dev path uses for these exact calls (server.ts).
             await wrapLogError('destroyCollectStories', () => destroyCollectStories());
         }
-        ctx.componentDocs = await extractComponentDocs(ctx, server.moduleGraph);
+        ctx.componentDocs = await extractComponentDocs(ctx, server);
         const counts = buildCounts(ctx.storyFiles);
         const { viteConfig: buildViteConfigRaw } = await getViteConfigWithPlugins(false, ctx);
         const buildViteConfig = mergeViteConfig(buildViteConfigRaw, {
@@ -241,6 +241,10 @@ export async function build(ctx) {
                     // returns whatever the minifier left — `codegen-vue.spec.ts` fails
                     // on three cases with this on (#329).
                     minify: false,
+                    // CSS too, whatever a book's own config says: Vite's minifier strips the
+                    // comments story CSS is found by before it is wrapped in `@scope`. The
+                    // entry-css-merger minifies instead, after wrapping (#1441).
+                    cssMinify: false,
                     // Don't build in SSR mode
                     ssr: false,
                 });
@@ -250,7 +254,7 @@ export async function build(ctx) {
         const isolate = ctx.config.isolateStyles !== false;
         buildPlugins.push(userCssScopePlugin({ enabled: isolate }));
         buildPlugins.push(chromeCssScopePlugin({ enabled: isolate }));
-        buildPlugins.push(entryCssMergerPlugin({ isolateStyles: isolate }));
+        buildPlugins.push(entryCssMergerPlugin({ isolateStyles: isolate, minify: true }));
         for (const cb of changeViteConfigCallbacks) {
             await cb(buildViteConfig);
         }

package/dist/node/collect/runner.d.ts

@@ -31,11 +31,22 @@ export type Invoke = (name: string, data: unknown[]) => Promise<unknown>;
  */
 export declare function filenameOf(module: Readonly<EvaluatedModuleNode>, root: string): string;
 /**
- * The keys an externalised module added to `globalThis` when Node ran it. Node
- * caches that module, so once a worker's reset deletes them nothing installs them
- * again. Vue's development build sets `__VUE_HMR_RUNTIME__` this way, and a story
- * compiled with HMR code reads it at its top level (#1320).
+ * The keys a module Node ran itself added to `globalThis`. Node caches that module,
+ * so once a worker's reset deletes them nothing installs them again. Vue's
+ * development build sets `__VUE_HMR_RUNTIME__` this way, and a story compiled with
+ * HMR code reads it at its top level (#1320). Node runs a module either as an
+ * external, or when an inlined CommonJS module requires it: an installed Nuxt or
+ * Quasar book's `vue.cjs.prod.js` is inlined and requires `@vue/runtime-dom` (#1404).
  */
 export declare const globalsFromExternals: Set<string>;
+/**
+ * Lets a dependency Node runs natively import its own stylesheet. A `type: module`
+ * package's `.js` is externalised, and @primer/react 38's `dist` imports `.css`
+ * files, which Node has no format for (#1392). Nothing in collection reads a
+ * stylesheet, so for this thread it is an empty module; the book still gets it from
+ * Vite. Checked rather than assumed, because a runtime that is not Node, such as
+ * StackBlitz's, may not have the hook.
+ */
+export declare function stubStylesheetsForNode(): void;
 /** A runner over a module server, reached through `invoke`. `root` is the Vite root. */
 export declare function createRunner(invoke: Invoke, root: string, evaluatedModules?: EvaluatedModules): ModuleRunner;

package/dist/node/collect/runner.js

@@ -1,4 +1,5 @@
 import { existsSync } from 'node:fs';
+import * as nodeModule from 'node:module';
 import { createRequire } from 'node:module';
 import { dirname, isAbsolute, join } from 'node:path';
 import process from 'node:process';
@@ -68,13 +69,40 @@ export function filenameOf(module, root) {
     return join(root, 'virtual-module');
 }
 /**
- * The keys an externalised module added to `globalThis` when Node ran it. Node
- * caches that module, so once a worker's reset deletes them nothing installs them
- * again. Vue's development build sets `__VUE_HMR_RUNTIME__` this way, and a story
- * compiled with HMR code reads it at its top level (#1320).
+ * The keys a module Node ran itself added to `globalThis`. Node caches that module,
+ * so once a worker's reset deletes them nothing installs them again. Vue's
+ * development build sets `__VUE_HMR_RUNTIME__` this way, and a story compiled with
+ * HMR code reads it at its top level (#1320). Node runs a module either as an
+ * external, or when an inlined CommonJS module requires it: an installed Nuxt or
+ * Quasar book's `vue.cjs.prod.js` is inlined and requires `@vue/runtime-dom` (#1404).
  */
 export const globalsFromExternals = new Set();
 const ranExternals = new Set();
+const requiredModules = new Set();
+/** The `require` an inlined module gets, recording what each module it loads first installs. */
+function requireRecordingGlobals(filename) {
+    const nodeRequire = createRequire(filename);
+    const recording = (id) => {
+        const resolved = nodeRequire.resolve(id);
+        if (requiredModules.has(resolved)) {
+            return nodeRequire(id);
+        }
+        const before = new Set(Object.keys(globalThis));
+        try {
+            return nodeRequire(id);
+        }
+        finally {
+            requiredModules.add(resolved);
+            for (const key of Object.keys(globalThis)) {
+                if (!before.has(key)) {
+                    globalsFromExternals.add(key);
+                }
+            }
+        }
+    };
+    // `resolve`, `cache` and the rest, as the module expects of `require`.
+    return Object.assign(recording, nodeRequire);
+}
 async function importRecordingGlobals(file) {
     const before = new Set(Object.keys(globalThis));
     const imported = await import(file);
@@ -86,6 +114,25 @@ async function importRecordingGlobals(file) {
     }
     return imported;
 }
+const STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:[?#]|$)/;
+/**
+ * Lets a dependency Node runs natively import its own stylesheet. A `type: module`
+ * package's `.js` is externalised, and @primer/react 38's `dist` imports `.css`
+ * files, which Node has no format for (#1392). Nothing in collection reads a
+ * stylesheet, so for this thread it is an empty module; the book still gets it from
+ * Vite. Checked rather than assumed, because a runtime that is not Node, such as
+ * StackBlitz's, may not have the hook.
+ */
+export function stubStylesheetsForNode() {
+    if (typeof nodeModule.registerHooks !== 'function') {
+        return;
+    }
+    nodeModule.registerHooks({
+        load: (url, context, nextLoad) => STYLESHEET.test(url)
+            ? { format: 'module', source: 'export default {}', shortCircuit: true }
+            : nextLoad(url, context),
+    });
+}
 /** As vite-node did: a CJS package's named exports are read through its default. */
 class InteropEvaluator {
     root;
@@ -146,7 +193,7 @@ class InteropEvaluator {
         // own scope it redeclared it, a syntax error that failed every story of the book
         // (#1301). The closing brace goes on a new line: the code may end in a line comment.
         const run = new AsyncFunction(ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, ssrExportNameKey, 'require', 'exports', 'module', '__filename', '__dirname', `"use strict";{\n${code}\n}`);
-        await run(context[ssrModuleExportsKey], context[ssrImportMetaKey], context[ssrImportKey], context[ssrDynamicImportKey], context[ssrExportAllKey], context[ssrExportNameKey], createRequire(filename), cjsExports, moduleProxy, filename, dirname(filename));
+        await run(context[ssrModuleExportsKey], context[ssrImportMetaKey], context[ssrImportKey], context[ssrDynamicImportKey], context[ssrExportAllKey], context[ssrExportNameKey], requireRecordingGlobals(filename), cjsExports, moduleProxy, filename, dirname(filename));
     }
     async runExternalModule(file) {
         const imported = ranExternals.has(file) ? await import(file) : await importRecordingGlobals(file);

package/dist/node/collect/worker.js

@@ -6,7 +6,7 @@ import pc from 'picocolors';
 import { EvaluatedModules } from 'vite/module-runner';
 import { createDomEnv, resetDomEnv } from '../dom/env.js';
 import { invokeOver } from './rpc.js';
-import { createRunner, globalsFromExternals } from './runner.js';
+import { createRunner, globalsFromExternals, stubStylesheetsForNode } from './runner.js';
 import { serveTasks } from './task.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const _evaluatedModules = new EvaluatedModules();
@@ -63,6 +63,7 @@ if (!parentPort) {
 // The port it answers over is the one tasks arrive on, so nothing is handed over
 // per story.
 const _invoke = invokeOver(parentPort);
+stubStylesheetsForNode();
 serveTasks(parentPort, { invalidate, invalidateAll, collect });
 async function collect(payload) {
     const startTime = performance.now();

package/dist/node/docgen/build.d.ts

@@ -1,8 +1,8 @@
-import type { ModuleGraph } from 'vite';
+import type { ViteDevServer } from 'vite';
 import type { Context } from '../context.js';
 import type { StoryDocsResult } from './protocol.js';
 /**
  * The build's pass (#1159): with no reader to wait for, every story's named
  * components are extracted once, after collection, into what the book ships.
  */
-export declare function extractComponentDocs(ctx: Context, moduleGraph: ModuleGraph): Promise<Record<string, StoryDocsResult['components']>>;
+export declare function extractComponentDocs(ctx: Context, server: Pick<ViteDevServer, 'moduleGraph' | 'pluginContainer'>): Promise<Record<string, StoryDocsResult['components']>>;

package/dist/node/docgen/build.js

@@ -1,17 +1,18 @@
-import { componentsOfStory } from './components-of.js';
+import { componentsOfStory, storyOf } from './components-of.js';
 import { createDocgenService } from './service.js';
 /**
  * The build's pass (#1159): with no reader to wait for, every story's named
  * components are extracted once, after collection, into what the book ships.
  */
-export async function extractComponentDocs(ctx, moduleGraph) {
+export async function extractComponentDocs(ctx, server) {
     const docgen = createDocgenService({
         root: ctx.root,
         plugins: ctx.config.plugins,
         enabled: ctx.config.autoDocs !== false,
         bookOptions: typeof ctx.config.autoDocs === 'object' ? ctx.config.autoDocs : undefined,
         collected: Promise.resolve(),
-        componentsOf: storyId => componentsOfStory(ctx.storyFiles, moduleGraph, storyId),
+        storyOf: storyId => storyOf(ctx.storyFiles, storyId),
+        componentsOf: storyId => componentsOfStory(ctx.storyFiles, server, storyId),
     });
     if (!docgen.enabled) {
         return {};
@@ -27,8 +28,10 @@ export async function extractComponentDocs(ctx, moduleGraph) {
             const { components } = await docgen.request(storyId);
             // A built book is published, so an extractor's error stays on the build
             // machine: the component keeps its runtime props, as with auto-docs off (#1382).
+            // A result with neither is a file with nothing to document, such as a JSX
+            // story that names no component, and is not a failure.
             const read = Object.entries(components).filter(([file, result]) => {
-                if (!result.doc) {
+                if (!result.doc && result.error !== undefined) {
                     failed.set(file, result.error);
                 }
                 return result.doc;

package/dist/node/docgen/components-of.d.ts

@@ -1,7 +1,19 @@
-import type { ServerStoryFile } from '@poveste/shared';
-import type { ModuleGraph } from 'vite';
+import type { ServerStory, ServerStoryFile } from '@poveste/shared';
+import type { ViteDevServer } from 'vite';
+/** The story's own file, absolute, the framework collection gave it, and its own `autoDocs`. */
+export declare function storyOf(storyFiles: ServerStoryFile[], storyId: string): {
+    file: string;
+    supportPluginId: string;
+    autoDocs?: ServerStory['autoDocs'];
+} | undefined;
+/** The components a story names, and how many capitalised imports reached none. */
+export interface StoryComponents {
+    files: string[];
+    unresolved: number;
+}
 /**
- * The files a story's own module imports, as collection resolved them: the
- * components that story names. Other story files are left out.
+ * The files a story names: those its `component` field lists, when it has one; else
+ * what its own module imports, as collection resolved it, and the components its
+ * imports reach through re-exports (#1432). Other story files are left out.
  */
-export declare function componentsOfStory(storyFiles: ServerStoryFile[], moduleGraph: ModuleGraph, storyId: string): string[];
+export declare function componentsOfStory(storyFiles: ServerStoryFile[], server: Pick<ViteDevServer, 'moduleGraph' | 'pluginContainer'>, storyId: string): Promise<StoryComponents>;

package/dist/node/docgen/components-of.js

@@ -1,17 +1,37 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute } from 'pathe';
+import { storyComponents } from './reexports.js';
+/** The story's own file, absolute, the framework collection gave it, and its own `autoDocs`. */
+export function storyOf(storyFiles, storyId) {
+    const storyFile = storyFiles.find(file => file.story?.id === storyId);
+    return storyFile && { file: storyFile.path, supportPluginId: storyFile.supportPluginId, autoDocs: storyFile.story?.autoDocs };
+}
 /**
- * The files a story's own module imports, as collection resolved them: the
- * components that story names. Other story files are left out.
+ * The files a story names: those its `component` field lists, when it has one; else
+ * what its own module imports, as collection resolved it, and the components its
+ * imports reach through re-exports (#1432). Other story files are left out.
  */
-export function componentsOfStory(storyFiles, moduleGraph, storyId) {
-    const storyFile = storyFiles.find(file => file.story?.id === storyId);
+export async function componentsOfStory(storyFiles, server, storyId) {
+    const storyFile = storyOf(storyFiles, storyId)?.file;
+    if (!storyFile) {
+        return { files: [], unresolved: 0 };
+    }
+    const resolve = async (specifier, importer) => {
+        const id = (await server.pluginContainer.resolveId(specifier, importer, { ssr: true }))?.id.split('?')[0];
+        return id && isAbsolute(id) && existsSync(id) ? id : undefined;
+    };
+    const traced = await storyComponents(storyFile, resolve).catch(() => ({ files: [], named: false, unresolved: 0 }));
+    if (traced.named) {
+        return { files: traced.files, unresolved: traced.unresolved };
+    }
     const storyPaths = new Set(storyFiles.map(file => file.path));
-    const files = new Set();
-    for (const mod of moduleGraph.getModulesByFile(storyFile?.path ?? '') ?? []) {
+    const files = new Set(traced.files);
+    for (const mod of server.moduleGraph.getModulesByFile(storyFile) ?? []) {
         for (const imported of mod.importedModules) {
             if (imported.file && !storyPaths.has(imported.file)) {
                 files.add(imported.file);
             }
         }
     }
-    return [...files];
+    return { files: [...files], unresolved: traced.unresolved };
 }

package/dist/node/docgen/engine.d.ts

@@ -5,11 +5,19 @@ export interface EngineExtractorSpec {
     module: string;
     options?: unknown;
 }
+/**
+ * An empty result is a file the extractor found nothing to document in, such as a story naming no component.
+ * A failure's `name` is the component's, when the extractor knew it and the file is not the component's own.
+ */
 export type ExtractResult = {
     doc: ComponentDoc;
 } | {
     doc?: undefined;
     error: string;
+    name?: string;
+} | {
+    doc?: undefined;
+    error?: undefined;
 };
 export interface DocgenEngineOptions {
     root: string;

package/dist/node/docgen/engine.js

@@ -61,10 +61,11 @@ export function createDocgenEngine(options) {
                 try {
                     const extractor = await extractorFor(name);
                     const doc = await extractor.extract(file);
-                    results[file] = doc ? { doc } : { error: 'no component found' };
+                    results[file] = doc ? { doc } : {};
                 }
                 catch (error) {
-                    results[file] = { error: describeError(error, options.root) };
+                    const component = error?.component;
+                    results[file] = { error: describeError(error, options.root), ...typeof component === 'string' ? { name: component } : {} };
                 }
                 await recycleIfNeeded();
             }

package/dist/node/docgen/jsx/extractor.d.ts

@@ -0,0 +1,8 @@
+import type { DocgenExtractor, DocgenExtractorContext } from '@poveste/shared';
+import type { JsxDialect } from './walk.js';
+/**
+ * The JSX frameworks' extractor, run in the docgen worker: one language service
+ * over the book's tsconfig, read through a dialect. A plugin's extractor module
+ * is this with its dialect bound.
+ */
+export declare function createJsxExtractor(context: DocgenExtractorContext, dialect: JsxDialect): DocgenExtractor;

package/dist/node/docgen/jsx/extractor.js

@@ -0,0 +1,79 @@
+import { existsSync } from 'node:fs';
+import { ambientFiles, loadFromBook, readTsconfig } from '../typed.js';
+import { documentStory } from './walk.js';
+function compilerOptions(typescript, parsed, dialect) {
+    return {
+        ...parsed
+            ? parsed.options
+            : {
+                jsx: typescript.JsxEmit.Preserve,
+                jsxImportSource: dialect.jsxImportSource,
+                module: typescript.ModuleKind.ESNext,
+                moduleResolution: typescript.ModuleResolutionKind.Bundler,
+                target: typescript.ScriptTarget.ESNext,
+                strict: true,
+                skipLibCheck: true,
+            },
+        // A `.story.jsx` is read whatever the book's tsconfig says, and nothing is emitted.
+        allowJs: true,
+        noEmit: true,
+    };
+}
+/**
+ * The JSX frameworks' extractor, run in the docgen worker: one language service
+ * over the book's tsconfig, read through a dialect. A plugin's extractor module
+ * is this with its dialect bound.
+ */
+export function createJsxExtractor(context, dialect) {
+    const typescript = loadFromBook(context.root, 'typescript', 'reads JSX components\' types');
+    const options = (context.options ?? {});
+    const parsed = readTsconfig(typescript, context.root);
+    const settings = compilerOptions(typescript, parsed, dialect);
+    // The requested stories and the book's declaration files, not every source it includes:
+    // the program grows with the components asked for, not with the book.
+    const files = new Set(ambientFiles(parsed));
+    const versions = new Map();
+    let projectVersion = 0;
+    const service = typescript.createLanguageService({
+        getProjectVersion: () => String(projectVersion),
+        getCompilationSettings: () => settings,
+        getScriptFileNames: () => [...files],
+        getScriptVersion: file => String(versions.get(file) ?? 0),
+        getScriptSnapshot(file) {
+            const text = typescript.sys.readFile(file);
+            return text === undefined ? undefined : typescript.ScriptSnapshot.fromString(text);
+        },
+        getCurrentDirectory: () => context.root,
+        getDefaultLibFileName: compilerOptions => typescript.getDefaultLibFilePath(compilerOptions),
+        fileExists: typescript.sys.fileExists,
+        readFile: typescript.sys.readFile,
+        readDirectory: typescript.sys.readDirectory,
+        directoryExists: typescript.sys.directoryExists,
+        getDirectories: typescript.sys.getDirectories,
+    });
+    function program() {
+        const current = service.getProgram();
+        if (!current) {
+            throw new Error('TypeScript built no program for the book');
+        }
+        return current;
+    }
+    return {
+        extract(file) {
+            if (!files.has(file)) {
+                files.add(file);
+                projectVersion++;
+            }
+            return documentStory(typescript, program(), file, dialect, options);
+        },
+        update(file) {
+            if (!existsSync(file)) {
+                files.delete(file);
+            }
+            versions.set(file, (versions.get(file) ?? 0) + 1);
+            projectVersion++;
+        },
+        sources: () => service.getProgram()?.getSourceFiles().map(sourceFile => sourceFile.fileName).filter(file => !file.includes('/node_modules/')) ?? [],
+        dispose: () => service.dispose(),
+    };
+}

package/dist/node/docgen/jsx/walk.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentDoc } from '@poveste/shared';
+import type ts from 'typescript';
+import type { DocgenOptions } from '../typed.js';
+/** What differs between JSX frameworks, as data, so Solid and React share one walker (#1110, #1161). */
+export interface JsxDialect {
+    /** Where the compiler finds the JSX types when the book has no tsconfig: `solid-js`, `react`. */
+    jsxImportSource: string;
+    /** Calls that merge an object of defaults into the props parameter: `mergeProps`. */
+    defaultCalls: string[];
+    /** A prop whose printed type matches is a slot: `JSX.Element`. */
+    slotType: RegExp;
+    /** The framework's types that give a component `children`: `ParentProps`, `PropsWithChildren`. */
+    childrenTypes: string[];
+}
+/**
+ * The component a story file's default export names in its `component` field,
+ * documented from the type of its first parameter. Nothing when the story names none,
+ * or names one `exclude` leaves out.
+ */
+export declare function documentStory(typescript: typeof ts, program: ts.Program, file: string, dialect: JsxDialect, options?: DocgenOptions): ComponentDoc | undefined;