forgebook 0.3.2 → 0.4.0

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

@@ -1,5 +1,6 @@
 import ts from "typescript-6";
 import type { PropDocs } from "../componentDocs.ts";
+import { type Bindings } from "./typeParameters.ts";
 /**
  * A symbol, through an import to what it names.
  *
@@ -40,6 +41,17 @@ export type PropReading = {
      * capital by default.
      */
     readonly eventName?: RegExp | undefined;
+    /**
+     * The same prop as the other variants of a union of props declare it (`selected?: Date` beside `selected?: Date[]`):
+     * their written types join its own. When their types differ, what only one of them would say (an event's signature,
+     * a value's shape, an object's members) is left out, and its kind is `other` unless all share one.
+     */
+    readonly variants?: readonly ts.Symbol[] | undefined;
+    /**
+     * What the props type's type parameters stand for in the component (`typeParameters.ts`), so a type parameter left
+     * open is shown by the component's constraint; none reads each by its own.
+     */
+    readonly bindings?: Bindings | undefined;
 };
 /**
  * One prop's docs.

package/dist/src/vite/propDocs.js

@@ -12,18 +12,11 @@
 import { dirname } from "node:path";
 import ts from "typescript-6";
 import { summaryOf, tagOf } from "./docsProgram.js";
+import { literalValues, typeAndKind } from "./propKind.js";
+import { propTypeNotes } from "./propTypeNotes.js";
+import { shapeOfProp } from "./shapeDocs.js";
 import { unwrapped } from "./storyMeta.js";
-/** An event: a function prop named `on` and a capital (React's `onPress`). */
-const EVENT_NAME = /^on[A-Z]/;
-/** Whether a type is a union of string or number literals (a choice). */
-const literalValues = (type) => {
-    if (!type.isUnion())
-        return undefined;
-    const values = type.types.map((member) => member.isStringLiteral() || member.isNumberLiteral() ? member.value : undefined);
-    return values.every((value) => value !== undefined)
-        ? values.filter((value) => value !== undefined)
-        : undefined;
-};
+import { genericFreeText, usesTypeParameter } from "./typeParameters.js";
 /** A literal value an expression writes (`"md"`, `3`, `-1`), or none for anything else. */
 const literalOfExpression = (expression) => {
     if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
@@ -131,25 +124,48 @@ const writtenLiterals = (node, checker, seen) => {
     return [...fromArguments, ...(alias === undefined ? [] : writtenLiterals(alias.type, checker, seen))];
 };
 /**
- * A choice's values in the order the source writes them: the checker's order follows the order it happened to meet
- * the types in, which a program kept between reads changes from one read to the next.
+ * What puts a choice's values in the order the source writes them: the checker's order follows the order it happened to
+ * meet the types in, which a program kept between reads changes from one read to the next.
+ *
+ * @remarks
+ * A prop's shape asks for the order of every union inside it, and a library's unions can hold hundreds of values (an
+ * icon's name): the declared values are read once per prop, on the first ask, and each value's place is looked up, not
+ * searched for.
  *
- * @param values - the values, in the checker's order.
  * @param declared - the prop's declared type nodes.
  * @param checker - the type checker.
- * @returns the values, those the source writes in its order first, any other after them in the checker's order.
+ * @returns the sorter: given values in the checker's order, those the source writes in its order first, any other
+ * after them in the checker's order.
  */
-const writtenOrder = (values, declared, checker) => {
-    const seen = new Set();
-    const written = declared.flatMap((node) => ts.isMethodSignature(node) ? [] : writtenLiterals(node, checker, seen));
-    const rank = (value) => {
-        const index = written.indexOf(value);
-        return index === -1 ? written.length : index;
+const writtenOrderOf = (declared, checker) => {
+    let places;
+    let unwritten = 0;
+    return (values) => {
+        if (places === undefined) {
+            const seen = new Set();
+            const written = declared.flatMap((node) => ts.isMethodSignature(node) ? [] : writtenLiterals(node, checker, seen));
+            places = new Map();
+            unwritten = written.length;
+            // a value written twice keeps its first place, as a search from the start would find it
+            for (const [index, value] of written.entries())
+                if (!places.has(value))
+                    places.set(value, index);
+        }
+        const known = places;
+        const rank = (value) => known.get(value) ?? unwritten;
+        return [...values].sort((left, right) => rank(left) - rank(right));
     };
-    return [...values].sort((left, right) => rank(left) - rank(right));
 };
 /** A choice's type as TypeScript writes it, its members in the given order (`"md" | "sm"`). */
 const choiceTypeText = (values) => values.map((value) => (typeof value === "string" ? JSON.stringify(value) : String(value))).join(" | ");
+/**
+ * Declarations by file and position: a prop several variants declare comes with them in the order the checker met
+ * the variants, which a program kept between reads changes.
+ *
+ * @param declarations - the declarations.
+ */
+const byPosition = (declarations) => [...declarations].sort((left, right) => left.getSourceFile().fileName.localeCompare(right.getSourceFile().fileName) ||
+    left.getStart() - right.getStart());
 /**
  * The props in the order the source declares them: those declared in the component's own folder first, then the
  * ones it takes from elsewhere, each by file and position. The checker's order follows the types it met first (an
@@ -160,7 +176,7 @@ const choiceTypeText = (values) => values.map((value) => (typeof value === "stri
  */
 export const declarationOrder = (props, componentFolder) => {
     const keyOf = (prop) => {
-        const [declaration] = prop.declarations ?? [];
+        const [declaration] = byPosition(prop.declarations ?? []);
         if (declaration === undefined)
             return [2, "", 0];
         const file = declaration.getSourceFile().fileName;
@@ -172,8 +188,15 @@ export const declarationOrder = (props, componentFolder) => {
         return leftOwn - rightOwn || leftFile.localeCompare(rightFile) || leftAt - rightAt;
     });
 };
-/** A type node's text as the source writes it, on one line. */
-const nodeText = (node) => node.getText().replace(/\s+/g, " ").trim();
+/**
+ * A type node's text as the source writes it, on one line; given a checker, each generic type parameter it uses
+ * replaced by what it is shown as (`typeParameters.ts`).
+ */
+const nodeText = (node, generic) => (generic === undefined ? node.getText() : genericFreeText(node, generic))
+    // an inline object's TSDoc is the docs' to read, not part of its type
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\s+/g, " ")
+    .trim();
 /**
  * Whether a type node adds nothing a prop can take: `undefined` and `null` (left out as the checker's `NonNullable`
  * did) and `never` (a branch of the props where the prop is not allowed).
@@ -200,7 +223,7 @@ const declaredMembers = (node) => {
  *
  * @param symbol - the prop.
  */
-const declaredTypesOf = (symbol) => (symbol.declarations ?? []).flatMap((declaration) => {
+const declaredTypesOf = (symbol) => byPosition(symbol.declarations ?? []).flatMap((declaration) => {
     if (ts.isMethodSignature(declaration))
         return [declaration];
     return (ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)) &&
@@ -214,36 +237,51 @@ const declaredTypesOf = (symbol) => (symbol.declarations ?? []).flatMap((declara
  * between reads changes from one read to the next.
  *
  * @param declaredTypes - the prop's declared type nodes.
+ * @param generic - the checker and the bindings when the prop's type is still generic, to replace the type parameters
+ * its text uses; none to write it as it is.
  * @returns the text, or none when the prop writes no type (the caller falls back to the checker's).
  */
-const writtenTypeText = (declaredTypes) => {
+const writtenTypeText = (declaredTypes, generic) => {
+    const text = (node) => nodeText(node, generic);
     const texts = declaredTypes.flatMap((declared) => {
         if (!ts.isMethodSignature(declared))
-            return declaredMembers(declared).map(nodeText);
-        const parameters = declared.parameters.map(nodeText).join(", ");
-        return [`(${parameters}) => ${declared.type === undefined ? "void" : nodeText(declared.type)}`];
+            return declaredMembers(declared).map(text);
+        const parameters = declared.parameters.map(text).join(", ");
+        return [`(${parameters}) => ${declared.type === undefined ? "void" : text(declared.type)}`];
     });
     // each branch's members once, in the order the branches write them
     const unique = [...new Set(texts)];
     return unique.length === 0 ? undefined : unique.join(" | ");
 };
+/**
+ * A prop's type as the source writes it, or none for the checker's: a text naming a type parameter the component
+ * instantiates (`value: TValue` in `BaseProps<string>`) says less than the checker's `string`.
+ *
+ * @param declared - the prop's declared types.
+ * @param generic - the checker and the bindings when the prop's type is still generic.
+ * @param checker - the program's checker.
+ */
+const writtenText = (declared, generic, checker) => generic === undefined && usesTypeParameter(declared, checker)
+    ? undefined
+    : writtenTypeText(declared, generic);
 /**
  * An event's signature as the source writes it: a function type among the prop's declared members, or a method.
  *
  * @param declaredTypes - the event prop's declared type nodes.
+ * @param generic - the checker and the bindings when the event's type is still generic, as `writtenTypeText` takes them.
  * @returns the signature, or none when the source writes none in place (a named handler type).
  */
-const writtenSignature = (declaredTypes) => {
+const writtenSignature = (declaredTypes, generic) => {
     const nodes = declaredTypes.flatMap((declared) => ts.isMethodSignature(declared) ? [declared] : declaredMembers(declared));
     const fn = nodes.find((node) => ts.isMethodSignature(node) || ts.isFunctionTypeNode(node));
     if (fn === undefined)
         return undefined;
     return {
         parameters: fn.parameters.map((parameter) => ({
-            name: nodeText(parameter.name),
-            type: parameter.type === undefined ? "unknown" : nodeText(parameter.type)
+            name: nodeText(parameter.name, undefined),
+            type: parameter.type === undefined ? "unknown" : nodeText(parameter.type, generic)
         })),
-        returns: fn.type === undefined ? "void" : nodeText(fn.type)
+        returns: fn.type === undefined ? "void" : nodeText(fn.type, generic)
     };
 };
 /** An event's signature. */
@@ -259,20 +297,6 @@ const signatureOf = (type, checker, node) => {
         returns: checker.typeToString(signature.getReturnType())
     };
 };
-/** A prop's kind, from its name and its type without `undefined`. */
-const kindOf = (name, type, eventName) => {
-    if (eventName.test(name) && type.getCallSignatures().length > 0)
-        return "event";
-    if (type.flags & ts.TypeFlags.Boolean || type.flags & ts.TypeFlags.BooleanLiteral)
-        return "toggle";
-    if (literalValues(type) !== undefined)
-        return "choice";
-    if (type.flags & ts.TypeFlags.String)
-        return "text";
-    if (type.flags & ts.TypeFlags.Number)
-        return "number";
-    return "other";
-};
 /** Whether a symbol is declared outside the package (a DOM attribute from React's types). */
 export const isForeign = (symbol) => (symbol.declarations ?? []).every((declaration) => declaration.getSourceFile().fileName.includes("/node_modules/"));
 /**
@@ -334,6 +358,22 @@ const groupingOf = (symbol, kind, type, checker, node) => {
         ...(members === undefined ? {} : { members })
     };
 };
+/**
+ * A choice's values across the variants' types that declare it, each once, in the order the source writes them.
+ *
+ * @param kind - the prop's kind: only a choice has values.
+ * @param types - its type in each variant, its own first.
+ * @param declared - its declared types, for their order.
+ * @param checker - the program's checker.
+ */
+const choicesOf = (kind, types, declared, checker) => {
+    if (kind !== "choice")
+        return undefined;
+    const lists = types.map(literalValues);
+    return lists.every((list) => list !== undefined)
+        ? writtenOrderOf(declared, checker)([...new Set(lists.flat())])
+        : undefined;
+};
 /**
  * One prop's docs.
  *
@@ -343,23 +383,26 @@ const groupingOf = (symbol, kind, type, checker, node) => {
  * @param reading - how the framework's props differ from a plain function's; none for a plain prop.
  */
 export const propDocs = (symbol, checker, node, reading = {}) => {
-    const { taken, eventName = EVENT_NAME } = reading;
-    const type = checker.getNonNullableType(taken?.type ?? checker.getTypeOfSymbolAtLocation(symbol, node));
+    const { taken, variants = [] } = reading;
     const takenNodes = taken?.typeNode === undefined ? [] : [taken.typeNode];
-    const declared = taken === undefined ? declaredTypesOf(symbol) : takenNodes;
+    const declared = taken === undefined ? [symbol, ...variants].flatMap(declaredTypesOf) : takenNodes;
+    const { type, variantTypes, isMixed, kind, generic } = typeAndKind(symbol, reading, checker, node);
     const name = symbol.getName();
-    const kind = kindOf(name, type, eventName);
     const defaultValue = tagOf(symbol, checker, "defaultValue");
-    const checkerChoices = kind === "choice" ? literalValues(type) : undefined;
-    const choices = checkerChoices === undefined ? undefined : writtenOrder(checkerChoices, declared, checker);
-    const signature = kind === "event" ? (writtenSignature(declared) ?? signatureOf(type, checker, node)) : undefined;
+    const choices = choicesOf(kind, [type, ...variantTypes], declared, checker);
+    // what one variant's type says of its values is not true of the others'
+    const signature = kind === "event" && !isMixed
+        ? (writtenSignature(declared, generic) ?? signatureOf(type, checker, node))
+        : undefined;
     // a node takes a text: the panel can set it as one, which covers labels, titles and children
-    const canTakeText = kind === "other" && checker.isTypeAssignableTo(checker.getStringType(), type);
+    const canTakeText = kind === "other" &&
+        [type, ...variantTypes].every((each) => checker.isTypeAssignableTo(checker.getStringType(), each));
+    const notes = propTypeNotes(declared, type, checker, generic);
     return {
         name,
         kind,
         type: choices === undefined
-            ? (writtenTypeText(declared) ?? checker.typeToString(type))
+            ? (writtenText(declared, generic, checker) ?? checker.typeToString(type))
             : choiceTypeText(choices),
         description: summaryOf(symbol, checker),
         isRequired: (symbol.flags & ts.SymbolFlags.Optional) === 0,
@@ -367,7 +410,36 @@ export const propDocs = (symbol, checker, node, reading = {}) => {
         ...(choices === undefined ? {} : { choices }),
         ...(signature === undefined ? {} : { signature }),
         ...(canTakeText ? { canTakeText } : {}),
-        ...groupingOf(symbol, kind, type, checker, node)
+        ...(isMixed
+            ? {}
+            : {
+                ...editingOf(symbol, { kind, type, canTakeText, declared, checker, node }),
+                ...groupingOf(symbol, kind, type, checker, node)
+            }),
+        ...(notes.length === 0 ? {} : { notes })
+    };
+};
+/**
+ * How a prop's value is edited, beyond its kind: what it looks like, and the tokens its TSDoc asks for.
+ *
+ * @param symbol - the prop.
+ * @param prop - what is known of it.
+ */
+const editingOf = (symbol, prop) => {
+    const { kind, type, canTakeText, declared, checker, node } = prop;
+    const shape = kind === "other"
+        ? shapeOfProp(type, canTakeText, {
+            checker,
+            node,
+            order: writtenOrderOf(declared, checker),
+            typeText: (member) => writtenTypeText(declaredTypesOf(member)),
+            description: (member) => summaryOf(member, checker)
+        })
+        : undefined;
+    const token = tagOf(symbol, checker, "token");
+    return {
+        ...(shape === undefined ? {} : { shape }),
+        ...(token === undefined || token === "" ? {} : { token })
     };
 };
 /** The props whose keys are the component's parts. */

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

@@ -0,0 +1,40 @@
+/**
+ * A prop's kind (the panel's group and control) and the type it is read from: a choice, a text, a number, a toggle, an
+ * event or anything else, across the variants of a union of props that declare it and through a generic's type
+ * parameters. Used by `propDocs.ts`.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import type { PropKind } from "../componentDocs.ts";
+import type { PropReading } from "./propDocs.ts";
+import { type Generics } from "./typeParameters.ts";
+/** Whether a type is a union of string or number literals (a choice). */
+export declare const literalValues: (type: ts.Type) => (string | number)[] | undefined;
+/** A prop's kind, from its name and its type without `undefined`. */
+export declare const kindOf: (name: string, type: ts.Type, eventName: RegExp) => PropKind;
+/** A prop's type and kind, read across the variants of a union of props that declare it. */
+export type TypeAndKind = {
+    /** Its type, without `undefined`: what a type parameter is shown as, for a prop typed by one. */
+    readonly type: ts.Type;
+    /** Its type in each other variant that declares it. */
+    readonly variantTypes: readonly ts.Type[];
+    /** Whether those variants type it otherwise. */
+    readonly isMixed: boolean;
+    /** Its kind, shared by every variant's type. */
+    readonly kind: PropKind;
+    /**
+     * The checker and the bindings when its type, as the component takes it, still holds a type parameter
+     * (`readonly TItem[]`): its text then replaces them. None otherwise.
+     */
+    readonly generic: Generics | undefined;
+};
+/**
+ * A prop's type and kind.
+ *
+ * @param symbol - the prop.
+ * @param reading - how the framework's props differ, and the other variants'.
+ * @param checker - the program's checker.
+ * @param node - where the code names the component.
+ */
+export declare const typeAndKind: (symbol: ts.Symbol, { taken, eventName, variants, bindings }: PropReading, checker: ts.TypeChecker, node: ts.Node) => TypeAndKind;

package/dist/src/vite/propKind.js

@@ -0,0 +1,71 @@
+/**
+ * A prop's kind (the panel's group and control) and the type it is read from: a choice, a text, a number, a toggle, an
+ * event or anything else, across the variants of a union of props that declare it and through a generic's type
+ * parameters. Used by `propDocs.ts`.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import { genericShownType, hasTypeParameter } from "./typeParameters.js";
+/** No bindings: each type parameter is shown by its own constraint. */
+const NO_BINDINGS = new Map();
+/** An event: a function prop named `on` and a capital (React's `onPress`). */
+const EVENT_NAME = /^on[A-Z]/;
+/** Whether a type is a union of string or number literals (a choice). */
+export const literalValues = (type) => {
+    if (!type.isUnion())
+        return undefined;
+    const values = type.types.map((member) => member.isStringLiteral() || member.isNumberLiteral() ? member.value : undefined);
+    return values.every((value) => value !== undefined)
+        ? values.filter((value) => value !== undefined)
+        : undefined;
+};
+/** A prop's kind, from its name and its type without `undefined`. */
+export const kindOf = (name, type, eventName) => {
+    if (eventName.test(name) && type.getCallSignatures().length > 0)
+        return "event";
+    if (type.flags & ts.TypeFlags.Boolean || type.flags & ts.TypeFlags.BooleanLiteral)
+        return "toggle";
+    if (literalValues(type) !== undefined)
+        return "choice";
+    if (type.flags & ts.TypeFlags.String)
+        return "text";
+    if (type.flags & ts.TypeFlags.Number)
+        return "number";
+    return "other";
+};
+/**
+ * A prop's kind across the variants that declare it: theirs when all share one, `other` otherwise.
+ *
+ * @param name - the prop's name.
+ * @param types - its type in each variant, without `undefined`.
+ * @param eventName - what an event's name is.
+ */
+const sharedKind = (name, types, eventName) => {
+    const kinds = new Set(types.map((type) => kindOf(name, type, eventName)));
+    const [only] = kinds;
+    return kinds.size === 1 && only !== undefined ? only : "other";
+};
+/**
+ * A prop's type and kind.
+ *
+ * @param symbol - the prop.
+ * @param reading - how the framework's props differ, and the other variants'.
+ * @param checker - the program's checker.
+ * @param node - where the code names the component.
+ */
+export const typeAndKind = (symbol, { taken, eventName = EVENT_NAME, variants = [], bindings }, checker, node) => {
+    const ownType = taken?.type ?? checker.getTypeOfSymbolAtLocation(symbol, node);
+    const isGeneric = hasTypeParameter(ownType, checker);
+    // a prop typed by a type parameter takes what that parameter is shown as: its kind and control follow from it
+    const shown = (each) => checker.getNonNullableType(genericShownType(each, checker) ?? each);
+    const type = shown(ownType);
+    const variantTypes = variants.map((variant) => shown(checker.getTypeOfSymbolAtLocation(variant, node)));
+    // two variants that write the same type have two of it: alike is what each accepts of the other
+    const isMixed = variantTypes.some((variantType) => !checker.isTypeAssignableTo(variantType, type) || !checker.isTypeAssignableTo(type, variantType));
+    const name = symbol.getName();
+    const kind = isMixed ? sharedKind(name, [type, ...variantTypes], eventName) : kindOf(name, type, eventName);
+    // a type parameter is replaced only where the component leaves it open: a props type it instantiates is read as is
+    const generic = isGeneric ? { checker, bindings: bindings ?? NO_BINDINGS } : undefined;
+    return { type, variantTypes, isMixed, kind, generic };
+};

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

@@ -0,0 +1,22 @@
+/**
+ * What a prop's type cannot say plainly: a generic's type parameter and what it is shown as (`typeParameters.ts`), a
+ * name the checker cannot find, an `any`. `propDocs` lists a note for each, so a reader sees why a type is not the one
+ * the source wrote, or why it says nothing.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import type { PropTypeNote } from "../componentDocs.ts";
+import { type DeclaredType, type Generics } from "./typeParameters.ts";
+/**
+ * Why a prop's type is not the one its source writes, or says nothing: each generic type parameter and what it is
+ * shown as, each name the checker cannot find, and an `any` with neither.
+ *
+ * @param declared - the prop's declared types.
+ * @param type - the prop's type as the checker has it, without `undefined`.
+ * @param checker - the program's checker.
+ * @param generics - the checker and the bindings when the component leaves a type parameter of the prop's type open;
+ * none otherwise.
+ * @returns the notes, in source order, each once; empty when the type is read as written.
+ */
+export declare const propTypeNotes: (declared: readonly DeclaredType[], type: ts.Type, checker: ts.TypeChecker, generics: Generics | undefined) => PropTypeNote[];

package/dist/src/vite/propTypeNotes.js

@@ -0,0 +1,51 @@
+/**
+ * What a prop's type cannot say plainly: a generic's type parameter and what it is shown as (`typeParameters.ts`), a
+ * name the checker cannot find, an `any`. `propDocs` lists a note for each, so a reader sees why a type is not the one
+ * the source wrote, or why it says nothing.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import { genericNotes, referencesIn } from "./typeParameters.js";
+/**
+ * Whether a type reference names something the checker cannot find: no symbol, or an import of nothing.
+ *
+ * @param reference - the reference.
+ * @param checker - the program's checker.
+ */
+const isUnresolved = (reference, checker) => {
+    const symbol = checker.getSymbolAtLocation(reference.typeName);
+    if (symbol === undefined)
+        return true;
+    const target = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (target.declarations ?? []).length === 0;
+};
+/**
+ * Why a prop's type is not the one its source writes, or says nothing: each generic type parameter and what it is
+ * shown as, each name the checker cannot find, and an `any` with neither.
+ *
+ * @param declared - the prop's declared types.
+ * @param type - the prop's type as the checker has it, without `undefined`.
+ * @param checker - the program's checker.
+ * @param generics - the checker and the bindings when the component leaves a type parameter of the prop's type open;
+ * none otherwise.
+ * @returns the notes, in source order, each once; empty when the type is read as written.
+ */
+export const propTypeNotes = (declared, type, checker, generics) => {
+    const notes = new Map();
+    for (const note of generics === undefined ? [] : genericNotes(declared, generics)) {
+        if (note.reason === "generic")
+            notes.set(`generic:${note.parameter}`, note);
+    }
+    for (const node of declared) {
+        for (const reference of referencesIn(node)) {
+            if (!isUnresolved(reference, checker))
+                continue;
+            const name = reference.typeName.getText();
+            notes.set(`unresolved:${name}`, { reason: "unresolved", name });
+        }
+    }
+    if (notes.size === 0 && type.flags & ts.TypeFlags.Any)
+        notes.set("any", { reason: "any" });
+    return [...notes.values()];
+};

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

@@ -0,0 +1,27 @@
+/** A published file, with the components it declares. */
+export type PublishedFile = {
+    /** The file, absolute. */
+    readonly file: string;
+    /** The names it publishes them under, in the order they are first met. */
+    readonly names: readonly string[];
+    /** Whether one of them plainly takes props: a parameter, a type argument. */
+    readonly takesProps: boolean;
+    /** Whether one of them has a doc comment on its declaration, or the file a `@module` one. */
+    readonly hasComment: boolean;
+};
+/** What `publishedComponents` asks of the disk. */
+export type ExportsDisk = {
+    /** A file's text; none when it does not exist. */
+    readonly readText: (file: string) => string | undefined;
+    /** The file a relative import names, from the file importing it; none when none is found or it is out of reach. */
+    readonly resolve: (specifier: string, from: string) => string | undefined;
+    /** Told of an import written through a project's alias, which this cannot follow. */
+    readonly onAlias?: (specifier: string, from: string) => void;
+};
+/**
+ * The components some entries publish, one element per declaring file.
+ *
+ * @param entries - the entries' source files, absolute.
+ * @param disk - what is asked of the disk.
+ */
+export declare const publishedComponents: (entries: readonly string[], disk: ExportsDisk) => PublishedFile[];