forgebook 0.1.7 → 0.2.0

package/dist/src/vite/functionComponentDocs.js

@@ -0,0 +1,193 @@
+/**
+ * The component of a story file whose components are functions of their props (React, Preact, Solid), read from its
+ * types and TSDoc: its props with their kind (the panel's group and control), its events' signatures and its parts. The
+ * docs modules of those frameworks (`@forgebook/react/docs`, `@forgebook/preact/docs`, `@forgebook/solid/docs`) hand
+ * these readers to the plugin's worker and `forgebook-docs` (`adapter.ts`).
+ *
+ * @remarks
+ * The component is the meta's `component`. Its props are the first parameter's properties declared in the package:
+ * what it passes on to the DOM (`ComponentProps<"button">`, `JSX.HTMLAttributes`) comes from `node_modules` and is left
+ * out. Events are `on*` props. Parts are the keys of the `classNames`, `styles` and `refs` maps (the
+ * reach-every-part rule).
+ *
+ * @module
+ */
+import { dirname } from "node:path";
+import ts from "typescript-6";
+import { chosenExport, programFor, summaryOf } from "./docsProgram.js";
+import { moduleSummaryOf } from "./moduleSummary.js";
+import { declarationOrder, declaredSymbol, isForeign, partsOf, propDocs } from "./propDocs.js";
+import { signatureDocs } from "./signatureDocs.js";
+import { metaComponent, metaSubcomponents } from "./storyMeta.js";
+import { guidanceOf } from "./usageGuidance.js";
+/**
+ * How a component is called: as a function of its props, or constructed with them into something that renders (a
+ * class component, which Preact and React still draw; another class is no component).
+ *
+ * @param type - the component's type.
+ */
+const componentSignatures = (type) => [
+    ...type.getCallSignatures(),
+    ...type
+        .getConstructSignatures()
+        .filter((signature) => signature.getReturnType().getProperty("render") !== undefined)
+];
+/**
+ * A component's props, read at the expression that names it.
+ *
+ * @param symbol - the component's symbol, through its import.
+ * @param expression - where the code names it.
+ * @param checker - the program's checker.
+ * @param storyFile - the story file, the folder when the component has no declaration.
+ */
+const componentProps = (symbol, expression, checker, storyFile) => {
+    const [signature] = componentSignatures(checker.getTypeOfSymbolAtLocation(symbol, expression));
+    const propsSymbol = signature?.parameters[0];
+    // a class's constructor takes its props as optional (`props?: P`): the props are `P`, not `P | undefined`
+    const propsType = propsSymbol === undefined
+        ? undefined
+        : checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(propsSymbol, expression));
+    const ownProps = declarationOrder((propsType?.getProperties() ?? []).filter((prop) => !isForeign(prop)), dirname(symbol.declarations?.[0]?.getSourceFile().fileName ?? storyFile));
+    return { propsType, ownProps };
+};
+/**
+ * The files a component's docs come from: the one declaring it and those declaring its own props.
+ *
+ * @param symbol - the component's symbol.
+ * @param ownProps - its own props.
+ * @param storyFile - the story file, when the component has no declaration.
+ */
+const docsSources = (symbol, ownProps, storyFile) => [
+    symbol.declarations?.[0]?.getSourceFile().fileName ?? storyFile,
+    ...ownProps.flatMap((prop) => (prop.declarations ?? []).map((declaration) => declaration.getSourceFile().fileName))
+];
+/**
+ * The docs of the subcomponents a story file's meta names, with the files they come from.
+ *
+ * @param source - the story file, parsed.
+ * @param checker - the program's checker.
+ * @returns the docs and their files, or a message naming the subcomponent that cannot be resolved.
+ */
+const subcomponentsOf = (source, checker) => {
+    const docs = [];
+    const sources = [];
+    for (const subcomponent of metaSubcomponents(source, checker)) {
+        const symbol = declaredSymbol(subcomponent.symbol, checker);
+        if (symbol === undefined) {
+            return `${source.fileName}: the meta's subcomponent ${subcomponent.name} cannot be resolved`;
+        }
+        const { ownProps } = componentProps(symbol, subcomponent.expression, checker, source.fileName);
+        docs.push({
+            name: subcomponent.name,
+            description: summaryOf(symbol, checker),
+            props: ownProps.map((prop) => propDocs(prop, checker, subcomponent.expression))
+        });
+        sources.push(...docsSources(symbol, ownProps, source.fileName));
+    }
+    return { docs, sources };
+};
+/**
+ * A component's docs and the files they come from, read at the expression that names it.
+ *
+ * @param symbol - the component's declared symbol.
+ * @param expression - where the code names it (the meta's `component`, or the export's own name).
+ * @param checker - the program's checker.
+ * @param file - the file read, the folder when the component has no declaration.
+ * @param subcomponents - the subcomponents' docs and files; none outside a story file.
+ */
+const componentOf = (symbol, expression, checker, file, subcomponents) => {
+    const { propsType, ownProps } = componentProps(symbol, expression, checker, file);
+    const props = ownProps.map((prop) => propDocs(prop, checker, expression));
+    const parts = partsOf(propsType, checker, expression);
+    const declarationFile = symbol.declarations?.[0]?.getSourceFile();
+    const sources = docsSources(symbol, ownProps, file);
+    const signature = signatureDocs(symbol, expression, checker);
+    return {
+        docs: {
+            name: symbol.getName(),
+            description: summaryOf(symbol, checker),
+            summary: declarationFile === undefined ? "" : moduleSummaryOf(declarationFile.text),
+            props,
+            parts,
+            subcomponents: subcomponents.docs,
+            ...guidanceOf(symbol, checker),
+            ...(signature === undefined ? {} : { signature })
+        },
+        file: sources[0] ?? file,
+        sources: [...new Set([...sources, ...subcomponents.sources])]
+    };
+};
+/**
+ * A story file's component with the file that declares it.
+ *
+ * @param storyFile - the story file's absolute path.
+ * @returns the component, `{ docs: { name: null } }` when the meta names none, or a message saying why the file
+ * cannot be read.
+ */
+export const functionStoryComponent = (storyFile) => {
+    const program = programFor(storyFile);
+    if (typeof program === "string")
+        return program;
+    const { checker } = program;
+    const source = program.program.getSourceFile(storyFile);
+    if (source === undefined)
+        return `${storyFile} is not in its program`;
+    const expression = metaComponent(source);
+    if (expression === undefined)
+        return { docs: { name: null } };
+    const symbol = declaredSymbol(checker.getSymbolAtLocation(expression), checker);
+    if (symbol === undefined)
+        return `${storyFile}: the meta's component cannot be resolved`;
+    const subcomponents = subcomponentsOf(source, checker);
+    if (typeof subcomponents === "string")
+        return subcomponents;
+    return componentOf(symbol, expression, checker, storyFile, subcomponents);
+};
+/**
+ * The docs of a story file's component, without the files they come from.
+ *
+ * @param storyFile - the story file's absolute path.
+ * @returns the component's docs, `{ name: null }` when the meta names no component, or a message saying why the file
+ * cannot be read.
+ */
+export const functionComponentDocs = (storyFile) => {
+    const component = functionStoryComponent(storyFile);
+    return typeof component === "string" ? component : component.docs;
+};
+/** Whether an export is a component: a name in PascalCase whose value can be called or constructed. */
+const isComponentExport = (symbol, checker, node) => /^[A-Z]/.test(symbol.getName()) &&
+    componentSignatures(checker.getTypeOfSymbolAtLocation(symbol, node)).length > 0;
+/**
+ * A component a file exports, read from its types, for writing its first stories (`forgebook new`).
+ *
+ * @param file - the component's file, absolute.
+ * @param exportName - the export to read; the file's only component when none.
+ * @returns the component, or a message saying why it cannot be read (no component, several, a name not exported).
+ */
+export const functionFileComponent = (file, exportName) => {
+    const program = programFor(file);
+    if (typeof program === "string")
+        return program;
+    const { checker } = program;
+    const source = program.program.getSourceFile(file);
+    if (source === undefined)
+        return `${file} is not in its program`;
+    const moduleSymbol = checker.getSymbolAtLocation(source);
+    if (moduleSymbol === undefined)
+        return `${file} exports nothing`;
+    const components = checker
+        .getExportsOfModule(moduleSymbol)
+        .filter((each) => isComponentExport(declaredSymbol(each, checker) ?? each, checker, source));
+    const chosen = chosenExport(components.map((each) => each.getName()), exportName, file);
+    if (typeof chosen !== "string")
+        return chosen.problem;
+    const export_ = components.find((each) => each.getName() === chosen);
+    if (export_ === undefined)
+        return `${file} exports no component ${chosen}`;
+    const symbol = declaredSymbol(export_, checker) ?? export_;
+    const declaration = symbol.declarations?.[0];
+    const name = declaration === undefined ? undefined : ts.getNameOfDeclaration(declaration);
+    if (name === undefined || !ts.isIdentifier(name))
+        return `${file}: ${export_.getName()} has no name to read it at`;
+    return componentOf(symbol, name, checker, file, { docs: [], sources: [] });
+};

package/dist/src/vite/gitChange.d.ts

@@ -0,0 +1,56 @@
+import { type VitePaths } from "./vitePaths.ts";
+/** A change. */
+export type GitChange = {
+    /** Its unified diff, with no context. */
+    readonly diff: string;
+    /** The files it deletes, relative to the repository. */
+    readonly deleted: readonly string[];
+    /** The new files git does not track yet, relative to the repository. */
+    readonly untracked: readonly string[];
+};
+/**
+ * Runs git in a folder.
+ *
+ * @param dir - a folder of the repository.
+ * @param args - its arguments.
+ * @returns what it wrote.
+ */
+export declare const gitOutput: (dir: string, ...args: readonly string[]) => Promise<string>;
+/**
+ * The commit a change starts from.
+ *
+ * @param dir - a folder of the repository.
+ * @param since - a commit, as asked.
+ * @returns its hash, or none when it names no commit.
+ */
+export declare const changeBase: (dir: string, since: string) => Promise<string | undefined>;
+/**
+ * The files a change touches, tracked or new.
+ *
+ * @param dir - a folder of the repository.
+ * @param base - the commit it starts from.
+ * @returns the repository's folder, and the files relative to it.
+ */
+export declare const changedFiles: (dir: string, base: string) => Promise<{
+    readonly root: string;
+    readonly files: readonly string[];
+}>;
+/**
+ * The changed files as the catalogue's graph names them: absolute, under the catalogue's folder as configured, in Vite's
+ * form. Git names real paths (with forward slashes on Windows too), and a folder reached through a link has another.
+ *
+ * @param dir - the catalogue's folder, as configured.
+ * @param realDir - the same folder with its links followed.
+ * @param root - the repository's folder, as git names it.
+ * @param files - the files, relative to the repository.
+ * @param paths - the path functions; the running system's unless a test names another.
+ */
+export declare const catalogueChangedFiles: (dir: string, realDir: string, root: string, files: readonly string[], paths?: VitePaths) => string[];
+/**
+ * Reads a change.
+ *
+ * @param dir - a folder of the repository.
+ * @param since - a commit, as asked.
+ * @returns the change, or why it cannot be read.
+ */
+export declare const gitChange: (dir: string, since: string) => Promise<GitChange | string>;

package/dist/src/vite/gitChange.js

@@ -0,0 +1,86 @@
+/**
+ * A change, as git names it: the commit it starts from, the diff, and the files git does not track yet.
+ *
+ * @remarks
+ * `since` comes from a request, so it is resolved as a commit before anything else: passed on as it is, git takes
+ * `--output=…` for an option and overwrites a file. The diff asks for one fixed form whatever the user's git settings,
+ * since colours, external diff tools and other prefixes all read as an empty change, which is a check passing with
+ * nothing checked. A change starts where the branch left `since`, or what `since` gained afterwards is read as this
+ * change's.
+ *
+ * @module
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { VITE_PATHS } from "./vitePaths.js";
+/** The largest output read, in bytes: a change this size is for a person, not for this check. */
+const MAX_OUTPUT = 64 * 1024 * 1024;
+const run = promisify(execFile);
+/**
+ * Runs git in a folder.
+ *
+ * @param dir - a folder of the repository.
+ * @param args - its arguments.
+ * @returns what it wrote.
+ */
+export const gitOutput = async (dir, ...args) => (await run("git", ["-c", "core.quotePath=false", ...args], { cwd: dir, maxBuffer: MAX_OUTPUT })).stdout;
+/** The lines of a list git wrote. */
+const listed = (text) => text.split("\n").filter((line) => line !== "");
+/**
+ * The commit a change starts from.
+ *
+ * @param dir - a folder of the repository.
+ * @param since - a commit, as asked.
+ * @returns its hash, or none when it names no commit.
+ */
+export const changeBase = async (dir, since) => {
+    try {
+        const commit = (await gitOutput(dir, "rev-parse", "--verify", "--quiet", "--end-of-options", `${since}^{commit}`)).trim();
+        return (await gitOutput(dir, "merge-base", commit, "HEAD")).trim();
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * The files a change touches, tracked or new.
+ *
+ * @param dir - a folder of the repository.
+ * @param base - the commit it starts from.
+ * @returns the repository's folder, and the files relative to it.
+ */
+export const changedFiles = async (dir, base) => {
+    const root = (await gitOutput(dir, "rev-parse", "--show-toplevel")).trim();
+    const tracked = listed(await gitOutput(dir, "diff", "--no-ext-diff", "--name-only", base, "--"));
+    const untracked = listed(await gitOutput(dir, "ls-files", "--others", "--exclude-standard", "--full-name"));
+    return { root, files: [...new Set([...tracked, ...untracked])] };
+};
+/**
+ * The changed files as the catalogue's graph names them: absolute, under the catalogue's folder as configured, in Vite's
+ * form. Git names real paths (with forward slashes on Windows too), and a folder reached through a link has another.
+ *
+ * @param dir - the catalogue's folder, as configured.
+ * @param realDir - the same folder with its links followed.
+ * @param root - the repository's folder, as git names it.
+ * @param files - the files, relative to the repository.
+ * @param paths - the path functions; the running system's unless a test names another.
+ */
+export const catalogueChangedFiles = (dir, realDir, root, files, paths = VITE_PATHS) => files.map((file) => paths.join(dir, paths.relative(realDir, paths.join(root, file))));
+/**
+ * Reads a change.
+ *
+ * @param dir - a folder of the repository.
+ * @param since - a commit, as asked.
+ * @returns the change, or why it cannot be read.
+ */
+export const gitChange = async (dir, since) => {
+    const base = await changeBase(dir, since);
+    if (base === undefined)
+        return `"${since}" names no commit here`;
+    const form = ["--no-ext-diff", "--no-textconv", "--no-color", "--src-prefix=a/", "--dst-prefix=b/"];
+    return {
+        diff: await gitOutput(dir, "diff", ...form, "--unified=0", base, "--"),
+        deleted: listed(await gitOutput(dir, "diff", ...form, "--name-only", "--diff-filter=D", base, "--")),
+        untracked: listed(await gitOutput(dir, "ls-files", "--others", "--exclude-standard", "--full-name"))
+    };
+};

package/dist/src/vite/heightsRoute.d.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** Where the heights' file is looked for. */
+export type HeightsFile = {
+    /** The file's address, relative to the pages (`story-heights.json`). */
+    readonly heights: string;
+    /** The pages' base path (`/`, or Vite's `base`). */
+    readonly base: string;
+    /** The public folder, or `false` when the project has none. */
+    readonly publicDir: string | false;
+};
+/**
+ * Whether a request asks for the heights' file while it does not exist.
+ *
+ * @param url - the request's path, with its query.
+ * @param file - where the file is.
+ * @param exists - whether a path exists; the file system's by default.
+ */
+export declare const isMissingHeights: (url: string, file: HeightsFile, exists?: (path: string) => boolean) => boolean;
+/**
+ * The middleware that answers a request for the missing heights' file with no content.
+ *
+ * @param file - where the file is.
+ */
+export declare const missingHeightsMiddleware: (file: HeightsFile) => (request: IncomingMessage, response: ServerResponse, next: () => void) => void;

package/dist/src/vite/heightsRoute.js

@@ -0,0 +1,42 @@
+/**
+ * The dev server's answer for the stories' heights while they have not been measured: the configuration names the
+ * file (`heights`), `forgebook-heights` writes it into the public folder, and until then the page asks for it on
+ * every load.
+ *
+ * @remarks
+ * A missing file is answered "no content" (204) instead of "not found": the shell reads it as no heights and waits at
+ * a guess, as it does without the file, and the browser's console stays free of an error that asks nothing of the
+ * user. Once the file exists, Vite serves it from the public folder as any other.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Whether a request asks for the heights' file while it does not exist.
+ *
+ * @param url - the request's path, with its query.
+ * @param file - where the file is.
+ * @param exists - whether a path exists; the file system's by default.
+ */
+export const isMissingHeights = (url, file, exists = existsSync) => {
+    const path = url.split("?")[0] ?? url;
+    const base = file.base.endsWith("/") ? file.base : `${file.base}/`;
+    if (path !== `${base}${file.heights}`)
+        return false;
+    return file.publicDir === false || !exists(join(file.publicDir, file.heights));
+};
+/**
+ * The middleware that answers a request for the missing heights' file with no content.
+ *
+ * @param file - where the file is.
+ */
+export const missingHeightsMiddleware = (file) => (request, response, next) => {
+    if (!isMissingHeights(request.url ?? "/", file)) {
+        next();
+        return;
+    }
+    response.statusCode = 204;
+    response.setHeader("Cache-Control", "no-store");
+    response.end();
+};

package/dist/src/vite/highlightCode.d.ts

@@ -13,4 +13,3 @@ export declare const escapeHtml: (text: string) => string;
  * @param language - its language as a Markdown fence names it (`tsx`, `ts`, `scss`, `sh`); none leaves it plain.
  */
 export declare const highlightCode: (code: string, language: string | undefined) => string;
-//# sourceMappingURL=highlightCode.d.ts.map

package/dist/src/vite/highlightCode.js

@@ -4,31 +4,17 @@
  *
  * @remarks
  * The TypeScript family (TypeScript, TSX, JavaScript, JSX) is split by the TypeScript compiler
- * (`typeScriptPieces.ts`): highlight.js reads JSX as HTML and loses the rest of the example at the first function or
- * `>` in an attribute. highlight.js keeps the other languages a component's documentation writes (CSS, SCSS,
- * JSON, bash, HTML), on its own instance, so nothing else that uses highlight.js in the same process sees these
- * settings. Both write the same classes, with the catalogue's prefix (`forgebook-hl-keyword`), coloured by the
- * shell's style sheet with its code palette. A language neither knows is escaped and left plain.
+ * (`typeScriptPieces.ts`), and the other languages a component's documentation writes by short grammars
+ * (`plainGrammars.ts`). Both give the same roles, written as the same classes, with the catalogue's prefix
+ * (`forgebook-hl-keyword`), coloured by the shell's style sheet with its code palette. A language neither knows is escaped
+ * and left plain.
  *
  * @module
  */
-import hljs from "highlight.js/lib/core";
-import bash from "highlight.js/lib/languages/bash";
-import css from "highlight.js/lib/languages/css";
-import json from "highlight.js/lib/languages/json";
-import scss from "highlight.js/lib/languages/scss";
-import xml from "highlight.js/lib/languages/xml";
+import { grammarPieces } from "./plainGrammars.js";
 import { isTypeScriptLanguage, typeScriptPieces } from "./typeScriptPieces.js";
 /** The class prefix of every coloured piece. */
 export const HIGHLIGHT_PREFIX = "forgebook-hl-";
-/** The catalogue's own highlighter: the languages outside the TypeScript family a component's documentation writes. */
-const highlighter = hljs.newInstance();
-highlighter.configure({ classPrefix: HIGHLIGHT_PREFIX });
-highlighter.registerLanguage("xml", xml);
-highlighter.registerLanguage("css", css);
-highlighter.registerLanguage("scss", scss);
-highlighter.registerLanguage("json", json);
-highlighter.registerLanguage("bash", bash);
 /** The characters HTML gives a meaning to, as entities. */
 const ENTITIES = {
     "&": "&",
@@ -43,10 +29,7 @@ const ENTITIES = {
  * @param text - the text.
  */
 export const escapeHtml = (text) => text.replace(/[&<>"']/g, (character) => ENTITIES[character] ?? character);
-/**
- * The classes of each role a TypeScript piece can have: the ones highlight.js gives the same thing, so the palette
- * colours both alike.
- */
+/** The classes of each role a piece can have. */
 const ROLE_CLASSES = {
     keyword: `${HIGHLIGHT_PREFIX}keyword`,
     string: `${HIGHLIGHT_PREFIX}string`,
@@ -75,8 +58,6 @@ export const highlightCode = (code, language) => {
         return escapeHtml(code);
     if (isTypeScriptLanguage(language))
         return typeScriptPieces(code, language).map(pieceHtml).join("");
-    if (highlighter.getLanguage(language) === undefined)
-        return escapeHtml(code);
-    return highlighter.highlight(code, { language, ignoreIllegals: true }).value;
+    const pieces = grammarPieces(code, language);
+    return pieces === undefined ? escapeHtml(code) : pieces.map(pieceHtml).join("");
 };
-//# sourceMappingURL=highlightCode.js.map

package/dist/src/vite/hotSnippets.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The code the dev server adds to a story file, to its docs, code and page modules and to a pattern's files module, so
+ * an edit reaches the open pages without a reload (`hotModules.ts` reads what it sends), and the plugin's hooks that add
+ * it to a story file and reload the pages for an edit that changes a pattern's list.
+ *
+ * @remarks
+ * Each module imports itself, as React's Fast Refresh does, to hand the page what it gave before beside what its
+ * successor gives: the page knows which value it drew, not which file it came from. Only the dev server adds them; a
+ * build has no hot updates.
+ *
+ * @module
+ */
+import type { Plugin } from "vite";
+import type { CloseWatch } from "./closeWatch.ts";
+import { type IndexedStoryFile } from "./storyFilesModule.ts";
+/**
+ * What a story file runs to accept its edit: the frame that draws its stories cancels the event and draws them anew;
+ * when none does, the files that import it take the edit (one that re-exports its stories draws them). The exports the
+ * page drew are kept in the module's hot data, so the version after one that threw while it loaded is matched with
+ * them, not with the version that failed.
+ *
+ * @param file - the story file's path, which it imports itself by.
+ */
+export declare const storyFileHot: (file: string) => string;
+/**
+ * A story file's code with its accepting code first: it runs before the file's own, so an edit that throws while the
+ * file loads still leaves the next one accepted. After the file's head and on its last line, so no line of the file
+ * moves and its source map stays true.
+ *
+ * @param code - the file's code, as the plugins before have made it.
+ * @param id - the file's path.
+ */
+export declare const withStoryFileHot: (code: string, id: string) => string;
+/**
+ * What a story file's docs, code or page module runs to hand its new default export to the shell that read the old one.
+ *
+ * @param id - the module's id, which it imports itself by.
+ */
+export declare const renewedModuleHot: (id: string) => string;
+/**
+ * A module as a dev server serves it: a story file's docs, code or page module hands its edit to the shell.
+ *
+ * @param id - the module's id.
+ * @param module - the module.
+ * @param queries - the queries of the modules that hand their edits on.
+ * @param isServing - whether a dev server serves it: a build has no hot updates.
+ */
+export declare const renewedModule: <TModule extends {
+    readonly code: string;
+}>(id: string, module: TModule, queries: readonly string[], isServing: boolean) => TModule;
+/**
+ * What a pattern's files module runs: it takes the edits its story files hand on, which change nothing it holds. An
+ * edit that changes its list reloads the pages from the server, and its pages keep the module they read.
+ */
+export declare const FILES_MODULE_HOT = "if (import.meta.hot) import.meta.hot.accept();";
+/** The patterns' modules a dev server served, with their story files indexed as it served them. */
+export type ServedPatterns = {
+    /**
+     * Keeps a pattern's module as it was served.
+     *
+     * @param id - the module's id.
+     * @param files - its story files, indexed.
+     */
+    readonly keep: (id: string, files: readonly IndexedStoryFile[]) => void;
+    /**
+     * The patterns' modules an edit of a story file changed (a story added or renamed, a title), which the open pages
+     * read once: the file alone is indexed again, not the pattern's every file. One that cannot be read yet (an edit
+     * half typed) changes nothing: its module shows the error, and the next edit is read again.
+     *
+     * @param file - the edited story file.
+     */
+    readonly changedBy: (file: string) => readonly string[];
+};
+/** The patterns' modules a dev server serves, kept to tell an edit that changes a list. */
+export declare const servedPatterns: () => ServedPatterns;
+/**
+ * The plugin's hooks for a story file's edit: the file accepts it on a dev server, and an edit that changes a pattern's
+ * list (a story added, renamed, a title) reloads the pages, which read the list once. A story file a frame loads is
+ * followed closely (`closeWatch.ts`), and the late report of an edit of any file the close watch handed on already is
+ * dropped, so an edit is drawn once.
+ *
+ * @param isServing - whether a dev server runs whose framework draws an edited story file in place.
+ * @param changedFilesModules - the patterns' modules the edit changed.
+ * @param watching - the dev server's close watch.
+ */
+export declare const storyFileHotHooks: (isServing: () => boolean, changedFilesModules: (file: string) => readonly string[], watching: Pick<CloseWatch, "follow" | "isLateReport">) => Pick<Plugin, "transform" | "hotUpdate">;