forgebook 0.1.8 → 0.3.0

package/dist/src/vite/searchRoute.js

@@ -0,0 +1,79 @@
+import { searchables, searchCatalogue } from "../search.js";
+import { isSearchIndex, mergedSearchIndex } from "../searchIndex.js";
+import { sourceSearchLoaders } from "../sourceFiles.js";
+import { componentAddressOf, docPageAddressOf, storyAddressOf } from "../viewState.js";
+import { settled } from "./agentRoutes.js";
+/** How many results an answer gives unless asked: agents degrade with long context. */
+const DEFAULT_LIMIT = 8;
+/** How many results an answer can give. */
+const MAX_LIMIT = 50;
+/** How many hits each result lists. */
+const HITS = 3;
+/** A marked text as plain text. */
+const plain = (text) => text.map((piece) => piece.text).join("");
+/** The address a search's target opens. */
+const addressOf = (target, pages, view) => {
+    if (target.kind === "story")
+        return storyAddressOf(pages.page, target.id, view);
+    const address = target.kind === "page"
+        ? docPageAddressOf(pages.page, target.id, view)
+        : componentAddressOf(pages.page, target.id, view);
+    return target.anchor === undefined ? address : `${address}#${encodeURIComponent(target.anchor)}`;
+};
+/** A hit as the document gives it. */
+const agentHit = (hit, pages, view) => ({
+    kind: hit.kind,
+    ...(hit.label === undefined ? {} : { name: plain(hit.label) }),
+    text: plain(hit.snippet),
+    address: addressOf(hit.target, pages, view)
+});
+/** A result as the document gives it. */
+const agentResult = (result, pages, view) => ({
+    kind: result.kind,
+    id: result.target.id,
+    name: plain(result.name),
+    place: result.place,
+    score: result.score,
+    matched: result.matched,
+    missed: result.missed,
+    reasons: result.reasons,
+    hits: result.hits.map((hit) => agentHit(hit, pages, view)),
+    hitCount: result.hitCount,
+    address: addressOf(result.target, pages, view)
+});
+/** A source's index, every group's read, with why one could not be. */
+const indexOf = async (source) => {
+    const read = await Promise.all(sourceSearchLoaders(source).map((load) => settled(load)));
+    const problems = read.flatMap((each) => ("error" in each ? [`${source.name}: ${each.error}`] : []));
+    const indexes = read.flatMap((each) => ("value" in each && isSearchIndex(each.value) ? [each.value] : []));
+    return { index: mergedSearchIndex(indexes), problems };
+};
+/** The limit asked for, within what an answer can give. */
+const limitOf = (text) => {
+    const limit = Number(text ?? DEFAULT_LIMIT);
+    return Number.isInteger(limit) && limit > 0 ? Math.min(limit, MAX_LIMIT) : DEFAULT_LIMIT;
+};
+/**
+ * What a query finds across the catalogue.
+ *
+ * @param context - what the routes read.
+ */
+export const searchAnswer = async ({ tree, params, pages, view, loaded }) => {
+    const query = params.get("query") ?? "";
+    if (query.trim() === "")
+        return { status: 400, body: { error: "No words to look for" } };
+    const read = await Promise.all(loaded.sources.map(async (source) => ({ id: source.id, ...(await indexOf(source)) })));
+    const indexes = new Map(read.map(({ id, index }) => [id, index]));
+    const answer = searchCatalogue(searchables(tree, indexes), query, {
+        results: limitOf(params.get("limit")),
+        hits: HITS
+    });
+    const body = {
+        schema: 1,
+        query,
+        total: answer.total,
+        results: answer.results.map((result) => agentResult(result, pages, view)),
+        problems: read.flatMap(({ index, problems }) => [...problems, ...(index.problems ?? [])])
+    };
+    return { status: 200, body };
+};

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

@@ -0,0 +1,31 @@
+/**
+ * Makes the dev server resolve a package on Node with the export conditions its pages resolve it with, so the stories
+ * and previews it loads for tools are the files the frames draw.
+ *
+ * @remarks
+ * Vite gives its server environment conditions of its own (`module`, `node`): a catalogue's `resolve.conditions`
+ * reaches the pages only. A monorepo that points its packages at their sources with a condition (`source`) is then
+ * read from their builds on the server, or not at all where nothing is built, and a preview that imports one cannot
+ * load there. So the server takes the pages' conditions too, except those of another runtime (`browser`, which would
+ * pick a package's browser build on Node, `worker`, `react-native`). A plugin that names the server's conditions
+ * itself (`ssr.resolve.conditions`, `environments.ssr.resolve.conditions`) keeps them. The hook runs after every other
+ * plugin's, so the conditions a framework's or the catalogue's plugins add are read as well; one a plugin sets in its
+ * `configEnvironment` hook is not. Only the `forgebook` command's server has it: an app that runs the catalogue's
+ * plugin in a Vite configuration of its own names the server's conditions there.
+ *
+ * @module
+ */
+import { type Plugin, type UserConfig } from "vite";
+/**
+ * The conditions the server resolves with for this configuration, or `undefined` to leave Vite's: none named for the
+ * pages, the server's named, or a server that runs as a web worker, which Vite gives the pages' conditions already.
+ *
+ * @param config - Vite's configuration, every plugin's included.
+ */
+export declare const serverConditionsOf: (config: UserConfig) => readonly string[] | undefined;
+/**
+ * The plugin.
+ *
+ * @returns a plugin that sets the server environment's conditions after the other plugins set theirs.
+ */
+export declare const serverConditions: () => Plugin;

package/dist/src/vite/serverConditions.js

@@ -0,0 +1,69 @@
+/**
+ * Makes the dev server resolve a package on Node with the export conditions its pages resolve it with, so the stories
+ * and previews it loads for tools are the files the frames draw.
+ *
+ * @remarks
+ * Vite gives its server environment conditions of its own (`module`, `node`): a catalogue's `resolve.conditions`
+ * reaches the pages only. A monorepo that points its packages at their sources with a condition (`source`) is then
+ * read from their builds on the server, or not at all where nothing is built, and a preview that imports one cannot
+ * load there. So the server takes the pages' conditions too, except those of another runtime (`browser`, which would
+ * pick a package's browser build on Node, `worker`, `react-native`). A plugin that names the server's conditions
+ * itself (`ssr.resolve.conditions`, `environments.ssr.resolve.conditions`) keeps them. The hook runs after every other
+ * plugin's, so the conditions a framework's or the catalogue's plugins add are read as well; one a plugin sets in its
+ * `configEnvironment` hook is not. Only the `forgebook` command's server has it: an app that runs the catalogue's
+ * plugin in a Vite configuration of its own names the server's conditions there.
+ *
+ * @module
+ */
+import { defaultServerConditions } from "vite";
+/**
+ * The conditions that name a build for another runtime than Node's: a package's browser build, a worker's, a native
+ * app's, another server runtime's. Node cannot run them, so the server leaves them out.
+ */
+const OTHER_RUNTIMES = new Set([
+    "browser",
+    "worker",
+    "react-native",
+    "deno",
+    "bun",
+    "workerd",
+    "edge-light"
+]);
+/**
+ * The conditions the server resolves with for this configuration, or `undefined` to leave Vite's: none named for the
+ * pages, the server's named, or a server that runs as a web worker, which Vite gives the pages' conditions already.
+ *
+ * @param config - Vite's configuration, every plugin's included.
+ */
+export const serverConditionsOf = (config) => {
+    const pages = config.environments?.["client"]?.resolve?.conditions ?? config.resolve?.conditions;
+    if (pages === undefined)
+        return undefined;
+    if (config.ssr?.target === "webworker")
+        return undefined;
+    if (config.ssr?.resolve?.conditions !== undefined)
+        return undefined;
+    if (config.environments?.["ssr"]?.resolve?.conditions !== undefined)
+        return undefined;
+    const forNode = pages.filter((condition) => !OTHER_RUNTIMES.has(condition));
+    return [...new Set([...forNode, ...defaultServerConditions])];
+};
+/**
+ * The plugin.
+ *
+ * @returns a plugin that sets the server environment's conditions after the other plugins set theirs.
+ */
+export const serverConditions = () => ({
+    name: "forgebook:server-conditions",
+    // a build loads nothing on the server, and an environment added to it would reach every plugin's hooks
+    apply: "serve",
+    config: {
+        order: "post",
+        handler: (config) => {
+            const conditions = serverConditionsOf(config);
+            return conditions === undefined
+                ? undefined
+                : { environments: { ssr: { resolve: { conditions: [...conditions] } } } };
+        }
+    }
+});

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

@@ -0,0 +1,18 @@
+/**
+ * A hook's or a function's signature, read from its types and TSDoc: what a story about logic documents first. Shared
+ * by the frameworks' docs modules.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import type { FunctionSignatureDocs } from "../componentDocs.ts";
+/**
+ * A hook's or a function's signature, read at the expression that names it: its type parameters, each parameter as
+ * the source writes it (a destructured one by its pattern, a rest one marked) with its `@param` text, and the return
+ * type with its `@returns` text. An overloaded function gives its first signature.
+ *
+ * @param symbol - the function's declared symbol.
+ * @param expression - where the code names it.
+ * @param checker - the program's checker.
+ */
+export declare const signatureDocs: (symbol: ts.Symbol, expression: ts.Expression, checker: ts.TypeChecker) => FunctionSignatureDocs | undefined;

package/dist/src/vite/signatureDocs.js

@@ -0,0 +1,64 @@
+/**
+ * A hook's or a function's signature, read from its types and TSDoc: what a story about logic documents first. Shared
+ * by the frameworks' docs modules.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+/**
+ * A type as the source writes it, on one line.
+ *
+ * @param node - the type's node.
+ */
+const writtenText = (node) => node.getText().replace(/\s+/g, " ").trim();
+/**
+ * A JSDoc tag's text on one line.
+ *
+ * @param comment - the tag's comment.
+ */
+const tagText = (comment) => (ts.getTextOfJSDocComment(comment) ?? "").replace(/^-\s*/, "").replace(/\s+/g, " ").trim();
+/**
+ * A hook's or a function's signature, read at the expression that names it: its type parameters, each parameter as
+ * the source writes it (a destructured one by its pattern, a rest one marked) with its `@param` text, and the return
+ * type with its `@returns` text. An overloaded function gives its first signature.
+ *
+ * @param symbol - the function's declared symbol.
+ * @param expression - where the code names it.
+ * @param checker - the program's checker.
+ */
+export const signatureDocs = (symbol, expression, checker) => {
+    const [signature] = checker.getTypeOfSymbolAtLocation(symbol, expression).getCallSignatures();
+    if (signature === undefined)
+        return undefined;
+    // a signature the checker made (a mapped or an intersected type) has no declaration
+    const declaration = signature.getDeclaration();
+    // a hook typed through an alias (`const useX: UseX = …`) has its comment on its own declaration, not the alias's
+    const ownTags = (symbol.declarations ?? []).flatMap((each) => [...ts.getJSDocTags(each)]);
+    const ownParameterTag = (name) => ownTags.filter(ts.isJSDocParameterTag).find((tag) => tag.name.getText() === name);
+    const parameters = signature.parameters.map((parameter) => {
+        const node = parameter.valueDeclaration;
+        const written = node !== undefined && ts.isParameter(node) ? node : undefined;
+        const tag = (written === undefined ? undefined : ts.getJSDocParameterTags(written)[0]) ??
+            ownParameterTag(parameter.getName());
+        return {
+            // a destructured parameter has no name of its own: the checker calls it `__0`
+            name: written === undefined || ts.isIdentifier(written.name)
+                ? parameter.getName()
+                : writtenText(written.name),
+            type: written?.type === undefined
+                ? checker.typeToString(checker.getTypeOfSymbolAtLocation(parameter, expression))
+                : writtenText(written.type),
+            description: tagText(tag?.comment),
+            isOptional: written?.questionToken !== undefined || written?.initializer !== undefined,
+            isRest: written?.dotDotDotToken !== undefined
+        };
+    });
+    const returnType = declaration?.type;
+    return {
+        typeParameters: (declaration?.typeParameters ?? []).map(writtenText),
+        parameters,
+        returns: returnType === undefined ? checker.typeToString(signature.getReturnType()) : writtenText(returnType),
+        returnsDescription: tagText(((declaration === undefined ? undefined : ts.getJSDocReturnTag(declaration)) ??
+            ownTags.find(ts.isJSDocReturnTag))?.comment)
+    };
+};

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

@@ -0,0 +1,57 @@
+import { type ParsedTokens } from "./designTokens.ts";
+/** What a source's module says of its tokens, its paths as written. */
+export type DeclaredSource = {
+    /** The source's id, when written plainly. */
+    readonly id: string | undefined;
+    /** Its tokens files, the base first. */
+    readonly tokens: readonly {
+        readonly file: string;
+        readonly mode: string | undefined;
+    }[];
+    /** What cannot be read of tokens it does declare. */
+    readonly problems: readonly string[];
+    /** Why the module could not be read, so whether it declares tokens is not known. */
+    readonly unread?: string;
+};
+/** A tokens file to read. */
+export type TokensFileToRead = {
+    /** Its absolute path. */
+    readonly path: string;
+    /** The theme it belongs to; none for the base. */
+    readonly mode: string | undefined;
+    /** What a problem calls it. */
+    readonly label: string;
+    /** The source it comes from; none for the catalogue's own. */
+    readonly source?: string;
+};
+/** A source's tokens files, ready to read. */
+export type SourceTokens = {
+    /** Its id, when written plainly. */
+    readonly id: string | undefined;
+    /** Its tokens files. */
+    readonly files: readonly TokensFileToRead[];
+    /** What cannot be read of tokens it does declare. */
+    readonly problems: readonly string[];
+    /** Why its module could not be read, so whether it declares tokens is not known. */
+    readonly unread?: string;
+};
+/**
+ * What a source's module declares, from its text.
+ *
+ * @param file - the module's path, for the parser (its extension says TypeScript or JSX).
+ * @param text - the module's text.
+ */
+export declare const declaredSource: (file: string, text: string) => DeclaredSource;
+/**
+ * What the source in a module gives, its paths absolute.
+ *
+ * @param file - the module's absolute path.
+ * @param name - what names the module, for the problems and the files' labels (`@acme/ui/stories`).
+ */
+export declare const sourceTokensIn: (file: string, name: string) => SourceTokens;
+/**
+ * Reads tokens files from disk.
+ *
+ * @param files - the files: each source's, then the catalogue's own.
+ */
+export declare const readTokenFiles: (files: readonly TokensFileToRead[]) => ParsedTokens;

package/dist/src/vite/sourceTokens.js

@@ -0,0 +1,164 @@
+/**
+ * What the module of a package's source declares, read without running it: its id and its tokens files; and tokens files
+ * read from disk, for the catalogue's answers and for `forgebook docs`.
+ *
+ * @remarks
+ * A source's module imports the stories' index, its texts and whatever its named values need, and only a catalogue's
+ * bundler answers those imports, so running it would let a broken story take the tokens down, and `forgebook docs` has
+ * no bundler at all. The text is enough when `export const source` is an object written plainly. A source built by code
+ * gives no id, and a `tokens` key inside it is a problem, named: its tokens would otherwise vanish in silence.
+ *
+ * A module that cannot be read says nothing either way, so it is `unread`, apart from `problems`: a tool shows it, but
+ * only tokens known to be declared stop a check, or every catalogue would fail on a source mid-edit that has none.
+ *
+ * A source's paths stay inside its package. A dependency writes them and the answers travel, so a path leading out would
+ * read files the dev server's `server.fs` never serves.
+ *
+ * @module
+ */
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { parseSync } from "vite";
+import { readTokens } from "./designTokens.js";
+import { propertyValue, unwrapped } from "./indexFields.js";
+/** What to do about tokens the module's text does not give. */
+const NOT_PLAIN = "tokens are read without running the module: write them as a list of strings or `{ file, mode }` in `export const source = { … }`";
+/** What a top-level `export const source = …` holds, if the statement is one. */
+const sourceValue = (statement) => {
+    if (statement.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "VariableDeclaration")
+        return undefined;
+    for (const declarator of statement.declaration.declarations) {
+        if (declarator.id.type === "Identifier" && declarator.id.name === "source" && declarator.init !== null)
+            return unwrapped(declarator.init);
+    }
+    return undefined;
+};
+/** Whether a syntax tree holds a `tokens` key: how a source built by code still shows it means tokens. */
+const holdsTokensKey = (node) => {
+    if (Array.isArray(node))
+        return node.some(holdsTokensKey);
+    if (typeof node !== "object" || node === null)
+        return false;
+    const isKey = "type" in node &&
+        node.type === "Property" &&
+        "key" in node &&
+        typeof node.key === "object" &&
+        node.key !== null &&
+        (("name" in node.key && node.key.name === "tokens") ||
+            ("value" in node.key && node.key.value === "tokens"));
+    return isKey || Object.values(node).some(holdsTokensKey);
+};
+/** A property's text, when it is written as one. */
+const plainText = (object, name) => {
+    const value = propertyValue(object, name);
+    return value?.type === "Literal" && typeof value.value === "string" ? value.value : undefined;
+};
+/** One entry of the list, or none when it is not written plainly. */
+const tokensEntry = (element) => {
+    if (element === null || element.type === "SpreadElement")
+        return undefined;
+    const entry = unwrapped(element);
+    if (entry.type === "Literal" && typeof entry.value === "string")
+        return { file: entry.value, mode: undefined };
+    if (entry.type !== "ObjectExpression")
+        return undefined;
+    const file = plainText(entry, "file");
+    const mode = plainText(entry, "mode");
+    return file === undefined || mode === undefined ? undefined : { file, mode };
+};
+/**
+ * What a source's module declares, from its text.
+ *
+ * @param file - the module's path, for the parser (its extension says TypeScript or JSX).
+ * @param text - the module's text.
+ */
+export const declaredSource = (file, text) => {
+    const { program, errors } = parseSync(file, text);
+    if (errors.length > 0) {
+        const unread = `it cannot be parsed: ${errors[0]?.message ?? ""}`;
+        return { id: undefined, tokens: [], problems: [], unread };
+    }
+    const value = program.body.map(sourceValue).find((each) => each !== undefined);
+    if (value?.type !== "ObjectExpression")
+        return { id: undefined, tokens: [], problems: holdsTokensKey(value ?? program.body) ? [NOT_PLAIN] : [] };
+    const object = value;
+    const id = plainText(object, "id");
+    const list = propertyValue(object, "tokens");
+    if (list === undefined)
+        return { id, tokens: [], problems: [] };
+    if (list.type !== "ArrayExpression")
+        return { id, tokens: [], problems: [NOT_PLAIN] };
+    const entries = list.elements.map(tokensEntry);
+    return {
+        id,
+        tokens: entries.filter((entry) => entry !== undefined),
+        problems: entries.includes(undefined) ? [NOT_PLAIN] : []
+    };
+};
+/** The folder of the package a module is in: the nearest with a manifest, or the module's own. */
+const packageRoot = (file) => {
+    const start = dirname(file);
+    for (let dir = start; dir !== dirname(dir); dir = dirname(dir)) {
+        if (existsSync(join(dir, "package.json")))
+            return dir;
+    }
+    return start;
+};
+/** Whether a path, its links followed where it exists, is inside a folder. */
+const isInside = (root, path) => {
+    const real = (each) => (existsSync(each) ? realpathSync(each) : each);
+    const fromRoot = relative(real(root), real(path));
+    return fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`) && !isAbsolute(fromRoot);
+};
+/**
+ * What the source in a module gives, its paths absolute.
+ *
+ * @param file - the module's absolute path.
+ * @param name - what names the module, for the problems and the files' labels (`@acme/ui/stories`).
+ */
+export const sourceTokensIn = (file, name) => {
+    let declared;
+    try {
+        declared = declaredSource(file, readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { id: undefined, files: [], problems: [], unread: `${name}: ${reason}` };
+    }
+    const source = declared.id ?? name;
+    const root = packageRoot(file);
+    const located = declared.tokens.map((each) => ({ ...each, path: resolve(dirname(file), each.file) }));
+    const outside = located.filter(({ path }) => !isInside(root, path));
+    return {
+        id: declared.id,
+        files: located
+            .filter(({ path }) => isInside(root, path))
+            .map(({ file: written, mode, path }) => ({ path, mode, label: `${name}: ${written}`, source })),
+        problems: [...declared.problems, ...outside.map((each) => `${each.file} is outside the package`)].map((problem) => `${name}: ${problem}`),
+        ...(declared.unread === undefined ? {} : { unread: `${name}: ${declared.unread}` })
+    };
+};
+/** A file's content as a reading's input, or none with a problem. */
+const fileInput = (file, unread) => {
+    const { path, mode, label, source } = file;
+    try {
+        const content = JSON.parse(readFileSync(path, "utf8"));
+        return [{ label, mode, file: content, ...(source === undefined ? {} : { source }) }];
+    }
+    catch (error) {
+        // the parser's message quotes the file, and a path may not lead to tokens at all
+        const reason = error instanceof SyntaxError ? "it is not JSON" : String(error);
+        unread.push(`${label}: ${reason}`);
+        return [];
+    }
+};
+/**
+ * Reads tokens files from disk.
+ *
+ * @param files - the files: each source's, then the catalogue's own.
+ */
+export const readTokenFiles = (files) => {
+    const unread = [];
+    const { tokens, problems, clashes } = readTokens(files.flatMap((file) => fileInput(file, unread)));
+    return { tokens, problems: [...unread, ...problems], clashes };
+};

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

@@ -25,4 +25,3 @@ export declare const dedented: (text: string, indent: number) => string;
  * @returns the texts by export name, or a message saying why the file cannot be read.
  */
 export declare const storyCode: (file: string, text: string) => Readonly<Record<string, string>> | string;
-//# sourceMappingURL=storyCode.d.ts.map

package/dist/src/vite/storyCode.js

@@ -9,7 +9,7 @@
  *
  * @module
  */
-import { parseSync } from "vite";
+import { parseStoryFile } from "./storyParse.js";
 /** An expression without the TypeScript wrappers around it (`satisfies`, `as`, parentheses). */
 const unwrapped = (expression) => {
     if (expression.type === "TSSatisfiesExpression" ||
@@ -61,7 +61,7 @@ const renderText = (declarator, text) => {
  * @returns the texts by export name, or a message saying why the file cannot be read.
  */
 export const storyCode = (file, text) => {
-    const { program, errors } = parseSync(file, text);
+    const { program, errors } = parseStoryFile(file, text);
     const [error] = errors;
     if (error !== undefined)
         return `${file} does not parse: ${error.message}`;
@@ -77,4 +77,3 @@ export const storyCode = (file, text) => {
     }
     return code;
 };
-//# sourceMappingURL=storyCode.js.map

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

@@ -0,0 +1,32 @@
+/**
+ * A story file's named exports, read from its parsed source: the names the index takes as stories.
+ *
+ * @remarks
+ * Kept apart from `indexStoryFile.ts`, which reads each export's fields. Pure.
+ *
+ * @module
+ */
+import type { ESTree } from "vite";
+/**
+ * One named export of the file: its exported name, the local name it points at (none for a re-export from another
+ * file), whether its statement declares it (`export const A = …`, not `export { A }`), and where the statement starts.
+ */
+export type NamedExport = {
+    /** The name it is exported as. */
+    readonly exportName: string;
+    /** The local name it points at; none for a re-export from another file. */
+    readonly local: string | undefined;
+    /** Whether its statement declares it (`export const A = …`), not only names it (`export { A }`). */
+    readonly isDeclared: boolean;
+    /** Where its statement starts. */
+    readonly start: number;
+};
+/** An export's or an import's name: an identifier's, or a string's (`export { A as "a story" }`). */
+export declare const moduleName: (name: ESTree.ModuleExportName) => string;
+/**
+ * The file's named exports that exist when it runs, in their order: declared ones and re-exports (`export { A as B }`,
+ * from this file or another); never the default export, a type, or the names of an `export *`.
+ *
+ * @param program - the parsed file.
+ */
+export declare const namedExports: (program: ESTree.Program) => NamedExport[];

package/dist/src/vite/storyExports.js

@@ -0,0 +1,27 @@
+/** An export's or an import's name: an identifier's, or a string's (`export { A as "a story" }`). */
+export const moduleName = (name) => name.type === "Literal" ? String(name.value) : name.name;
+/**
+ * The file's named exports that exist when it runs, in their order: declared ones and re-exports (`export { A as B }`,
+ * from this file or another); never the default export, a type, or the names of an `export *`.
+ *
+ * @param program - the parsed file.
+ */
+export const namedExports = (program) => program.body.flatMap((statement) => {
+    if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type")
+        return [];
+    const { declaration, start } = statement;
+    if (declaration?.type === "VariableDeclaration") {
+        return declaration.declarations.flatMap((declarator) => declarator.id.type === "Identifier"
+            ? [{ exportName: declarator.id.name, local: declarator.id.name, isDeclared: true, start }]
+            : []);
+    }
+    if (declaration?.type === "FunctionDeclaration" && declaration.id !== null)
+        return [{ exportName: declaration.id.name, local: declaration.id.name, isDeclared: true, start }];
+    return statement.specifiers.flatMap((specifier) => {
+        const exportName = moduleName(specifier.exported);
+        if (specifier.exportKind === "type" || exportName === "default")
+            return [];
+        const local = statement.source === null ? moduleName(specifier.local) : undefined;
+        return [{ exportName, local, isDeclared: false, start }];
+    });
+});