forgebook 0.3.2 → 0.4.0

package/dist/src/vite/tailwindConfigTokens.js

@@ -0,0 +1,306 @@
+/**
+ * The tokens a Tailwind configuration file writes, read from its text and never run.
+ *
+ * @remarks
+ * Pure. Running a project's configuration would run its code, which a read-only question must not do, so what is written
+ * plainly is read (objects, strings, a constant of the same file) and what needs code to know (a spread of something
+ * imported, a function, a plugin) is named in `unread`: a token this cannot see is a value that reads as hand-written.
+ * Each theme key is named as Tailwind 4 names it (`colors.primary.DEFAULT` is `--color-primary`), so one project reads
+ * the same in either version and a token's utility comes from its name alike.
+ *
+ * @module
+ */
+import { parseSync } from "vite";
+import { keyName, propertyValue, unwrapped } from "./indexFields.js";
+import { isTooDeep } from "./sourceText.js";
+/** The theme keys that hold tokens, with their namespace and type. */
+const THEME_KEYS = {
+    colors: { prefix: "--color-", type: "color" },
+    backgroundColor: { prefix: "--color-", type: "color" },
+    textColor: { prefix: "--color-", type: "color" },
+    borderColor: { prefix: "--color-", type: "color" },
+    spacing: { prefix: "--spacing-", type: "dimension" },
+    borderRadius: { prefix: "--radius-", type: "dimension" },
+    fontSize: { prefix: "--text-", type: "dimension" },
+    fontFamily: { prefix: "--font-", type: "fontFamily" },
+    fontWeight: { prefix: "--font-weight-", type: "fontWeight" },
+    lineHeight: { prefix: "--leading-", type: "number" },
+    letterSpacing: { prefix: "--tracking-", type: "tracking" },
+    boxShadow: { prefix: "--shadow-", type: "shadow" },
+    screens: { prefix: "--breakpoint-", type: "breakpoint" }
+};
+/** Words the values of a palette are never given as, in `tailwindcss/colors`. */
+const NOT_A_TOKEN = new Set(["inherit", "currentColor", "current"]);
+/** A string's text, a template with nothing in it included. */
+const stringOf = (node) => {
+    if (node.type === "Literal")
+        return typeof node.value === "string" ? node.value : undefined;
+    if (node.type === "TemplateLiteral" && node.expressions.length === 0)
+        return node.quasis[0]?.value.cooked ?? undefined;
+    return undefined;
+};
+/** A leaf's text: a string, a number, or a list's first (`fontSize: ["1rem", { lineHeight: … }]`) or all (a font stack). */
+const leafOf = (node, type) => {
+    const text = stringOf(node);
+    if (text !== undefined)
+        return text;
+    if (node.type === "Literal" && typeof node.value === "number")
+        return String(node.value);
+    if (node.type !== "ArrayExpression")
+        return undefined;
+    const parts = node.elements.flatMap((element) => element === null || element.type === "SpreadElement" ? [] : (stringOf(unwrapped(element)) ?? []));
+    return type === "fontFamily" ? parts.join(", ") : parts[0];
+};
+/** The palette a member expression names (`colors.blue`, `colors.blue[500]`), when its object is `tailwindcss/colors`. */
+const paletteOf = (value, walk) => {
+    if (value.type !== "MemberExpression")
+        return undefined;
+    const { object, property, computed } = value;
+    if (computed) {
+        const inner = paletteOf(object, walk);
+        return inner !== undefined && property.type === "Literal"
+            ? `${inner}-${String(property.value)}`
+            : undefined;
+    }
+    return object.type === "Identifier" && walk.palettes.has(object.name) && property.type === "Identifier"
+        ? property.name
+        : undefined;
+};
+/** Reads each key of an object under a name; `DEFAULT` is the name itself. */
+const walkObject = (object, name, { type, label }, walk) => {
+    for (const property of object.properties) {
+        const key = property.type !== "Property" || property.computed ? undefined : keyName(property.key);
+        if (property.type !== "Property" || key === undefined) {
+            walk.unread.push(`${label}: a part is built by code`);
+            continue;
+        }
+        const child = key === "DEFAULT" ? name : `${name}-${key}`;
+        walkValue(property.value, child, { type, label: `${label}.${key}` }, walk);
+    }
+};
+/** Reads a theme value under a name: an object of more names, a leaf, or something that needs running. */
+const walkValue = (node, name, place, walk) => {
+    const value = unwrapped(node);
+    const constant = value.type === "Identifier" ? walk.constants.get(value.name) : undefined;
+    if (constant !== undefined) {
+        walkValue(constant, name, place, walk);
+        return;
+    }
+    const palette = paletteOf(value, walk);
+    if (palette !== undefined) {
+        walk.paletteAliases.push({ name, palette });
+        return;
+    }
+    if (value.type === "ObjectExpression") {
+        walkObject(value, name, place, walk);
+        return;
+    }
+    const leaf = leafOf(value, place.type);
+    if (leaf === undefined)
+        walk.unread.push(`${place.label}: built by code`);
+    else if (!NOT_A_TOKEN.has(leaf))
+        walk.tokens.push({ name, value: leaf, type: place.type });
+};
+/** Reads one `theme` or `theme.extend` object, naming the keys it holds. */
+const walkTheme = (theme, label, walk) => {
+    const held = [];
+    for (const property of theme.properties) {
+        if (property.type !== "Property" || property.computed) {
+            walk.unread.push(`${label}: a part is built by code`);
+            continue;
+        }
+        const key = keyName(property.key);
+        const known = key === undefined ? undefined : THEME_KEYS[key];
+        if (key === undefined || key === "extend")
+            continue;
+        held.push(key);
+        if (known === undefined)
+            continue;
+        const value = unwrapped(property.value);
+        const prefix = known.prefix.slice(0, -1);
+        if (value.type === "ObjectExpression" || value.type === "Identifier") {
+            walkEntries(value, prefix, { type: known.type, label: `${label}.${key}` }, walk);
+        }
+        else {
+            walk.unread.push(`${label}.${key}: built by code`);
+        }
+    }
+    return held;
+};
+/** Reads a theme key's object: each of its keys under the namespace. */
+const walkEntries = (node, prefix, place, walk) => {
+    const value = node.type === "Identifier" ? (walk.constants.get(node.name) ?? node) : node;
+    if (value.type === "ObjectExpression")
+        walkObject(value, prefix, place, walk);
+    else
+        walk.unread.push(`${place.label}: built by code`);
+};
+/** A top-level `const x = …`'s name and value. */
+const constantsOf = (program) => {
+    const constants = new Map();
+    for (const statement of program.body) {
+        const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+        if (declaration?.type !== "VariableDeclaration")
+            continue;
+        for (const { id, init } of declaration.declarations) {
+            if (id.type === "Identifier" && init !== null)
+                constants.set(id.name, unwrapped(init));
+        }
+    }
+    return constants;
+};
+/** The module a `require("x")` names, when the expression is one. */
+const requiredModule = (node) => {
+    const call = unwrapped(node);
+    if (call.type !== "CallExpression" || call.callee.type !== "Identifier" || call.callee.name !== "require")
+        return undefined;
+    const [first] = call.arguments;
+    return first === undefined || first.type === "SpreadElement" ? undefined : stringOf(unwrapped(first));
+};
+/** Each name's module, from the file's imports and `require`s. */
+const importsOf = (program, constants) => {
+    const imports = new Map();
+    for (const statement of program.body) {
+        if (statement.type !== "ImportDeclaration")
+            continue;
+        for (const specifier of statement.specifiers) {
+            if (specifier.type !== "ImportSpecifier")
+                imports.set(specifier.local.name, String(statement.source.value));
+        }
+    }
+    for (const [name, value] of constants) {
+        const module = requiredModule(value);
+        if (module !== undefined)
+            imports.set(name, module);
+    }
+    return imports;
+};
+/** The object a file exports, through a helper's call (`defineConfig({…})`) and a constant. */
+const exportedObject = (program, constants) => {
+    const plain = (node) => {
+        const value = unwrapped(node);
+        if (value.type === "ObjectExpression")
+            return value;
+        if (value.type === "Identifier") {
+            const constant = constants.get(value.name);
+            return constant === undefined ? undefined : plain(constant);
+        }
+        if (value.type === "CallExpression") {
+            const [first] = value.arguments;
+            return first === undefined || first.type === "SpreadElement" ? undefined : plain(first);
+        }
+        return undefined;
+    };
+    for (const statement of program.body) {
+        if (statement.type === "ExportDefaultDeclaration") {
+            const { declaration } = statement;
+            return declaration.type === "FunctionDeclaration" ||
+                declaration.type === "ClassDeclaration" ||
+                declaration.type === "TSInterfaceDeclaration"
+                ? undefined
+                : plain(declaration);
+        }
+        if (statement.type === "ExpressionStatement" &&
+            statement.expression.type === "AssignmentExpression" &&
+            statement.expression.left.type === "MemberExpression" &&
+            statement.expression.left.object.type === "Identifier" &&
+            statement.expression.left.object.name === "module") {
+            return plain(statement.expression.right);
+        }
+    }
+    return undefined;
+};
+/** The modules a `presets` list names. */
+const presetsOf = (object, imports, unread) => {
+    const list = propertyValue(object, "presets");
+    if (list === undefined)
+        return [];
+    if (list.type !== "ArrayExpression") {
+        unread.push("presets: built by code");
+        return [];
+    }
+    return list.elements.flatMap((element) => {
+        if (element === null || element.type === "SpreadElement") {
+            unread.push("presets: a part is built by code");
+            return [];
+        }
+        const value = unwrapped(element);
+        const module = requiredModule(value) ?? (value.type === "Identifier" ? imports.get(value.name) : undefined);
+        if (module === undefined)
+            unread.push("presets: a part is built by code");
+        return module === undefined ? [] : [module];
+    });
+};
+/**
+ * Reads a Tailwind configuration's text.
+ *
+ * @param file - its path, for the parser (its extension says TypeScript).
+ * @param text - its text.
+ */
+export const readTailwindConfig = (file, text) => {
+    const empty = { tokens: [], presets: [], replaced: [], paletteAliases: [] };
+    if (isTooDeep(text))
+        return { ...empty, unread: ["it nests too deep to read"] };
+    const { program, errors } = parseSync(file, text);
+    if (errors.length > 0)
+        return { ...empty, unread: [`it cannot be parsed: ${errors[0]?.message ?? ""}`] };
+    const constants = constantsOf(program);
+    const object = exportedObject(program, constants);
+    if (object === undefined)
+        return { ...empty, unread: ["what it exports is built by code"] };
+    const imports = importsOf(program, constants);
+    const palettes = new Set([...imports].flatMap(([name, module]) => (module === "tailwindcss/colors" ? [name] : [])));
+    const walk = { tokens: [], unread: [], paletteAliases: [], constants, palettes };
+    const presets = presetsOf(object, imports, walk.unread);
+    const written = propertyValue(object, "theme");
+    // `{ theme }`, with a constant of the file above it
+    const theme = written?.type === "Identifier" ? (constants.get(written.name) ?? written) : written;
+    if (theme === undefined)
+        return { ...empty, presets, unread: walk.unread };
+    if (theme.type !== "ObjectExpression") {
+        return { ...empty, presets, unread: [...walk.unread, "theme: built by code"] };
+    }
+    const replaced = walkTheme(theme, "theme", walk);
+    const writtenExtend = propertyValue(theme, "extend");
+    const extend = writtenExtend?.type === "Identifier"
+        ? (constants.get(writtenExtend.name) ?? writtenExtend)
+        : writtenExtend;
+    if (extend?.type === "ObjectExpression")
+        walkTheme(extend, "theme.extend", walk);
+    else if (extend !== undefined)
+        walk.unread.push("theme.extend: built by code");
+    return {
+        tokens: walk.tokens,
+        unread: walk.unread,
+        presets,
+        replaced,
+        paletteAliases: walk.paletteAliases
+    };
+};
+/**
+ * The colours of Tailwind's default palette, from the text of `tailwindcss/lib/public/colors.js`: only an object of
+ * plain strings, read and not run, as any other file here.
+ *
+ * @param file - its path.
+ * @param text - its text.
+ * @returns each colour's name as Tailwind 4 names it, with its value.
+ */
+export const readTailwindPalette = (file, text) => {
+    if (isTooDeep(text))
+        return [];
+    const { program, errors } = parseSync(file, text);
+    if (errors.length > 0)
+        return [];
+    const palette = constantsOf(program).get("_default");
+    if (palette?.type !== "ObjectExpression")
+        return [];
+    const walk = {
+        tokens: [],
+        unread: [],
+        paletteAliases: [],
+        constants: new Map(),
+        palettes: new Set()
+    };
+    walkEntries(palette, "--color", { type: "color", label: "palette" }, walk);
+    return walk.tokens;
+};

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

@@ -0,0 +1,15 @@
+/**
+ * The files a style sheet's text imports: its own folder's, a package's and an address are not this package's.
+ *
+ * @param file - the sheet, absolute.
+ * @param text - its text.
+ * @param exists - whether a file exists.
+ */
+export declare const sheetImports: (file: string, text: string, exists?: (path: string) => boolean) => string[];
+/**
+ * Every relative asset a module's text names as a string.
+ *
+ * @param file - the module, absolute.
+ * @param text - its text.
+ */
+export declare const assetImports: (file: string, text: string) => string[];

package/dist/src/vite/textImports.js

@@ -0,0 +1,58 @@
+/**
+ * What a file's text says it imports, where no compiler can tell: a style sheet's own imports, and the sheets, templates
+ * and single-file components a module names as strings.
+ *
+ * @remarks
+ * Apart from `usageImports.ts`, which needs the compiler: the dev server's thread reads these too, for the sheets every
+ * story shows, and it must start without one.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { VITE_PATHS } from "./vitePaths.js";
+/** A relative path to a file TypeScript does not read, standing as a string, with any query Vite takes. */
+const ASSET_PATH = /["'`](\.{1,2}\/[^"'`\n?]+\.(?:css|scss|sass|less|vue|svelte|astro|html))(?:\?[^"'`\n]*)?["'`]/g;
+/** A style sheet's own imports. */
+const SHEET_USE = /@(?:use|forward)\s+["']([^"']+)["']/g;
+/** A sheet's `@import`, which may list several, or set Less's options first. */
+const SHEET_IMPORT = /@import\s+([^;\n]{1,2000})/g;
+/** A quoted name in an `@import`. */
+const QUOTED = /["']([^"']+)["']/g;
+/** Where a style sheet's import may be, from the name it writes: Sass omits the extension and the partial's `_`. */
+const sheetCandidates = (path) => {
+    const folder = VITE_PATHS.dirname(path);
+    const name = path.slice(folder.length + 1);
+    return [
+        path,
+        ...["scss", "sass", "css", "less"].flatMap((extension) => [
+            `${path}.${extension}`,
+            VITE_PATHS.join(folder, `_${name}.${extension}`),
+            VITE_PATHS.join(path, `_index.${extension}`),
+            VITE_PATHS.join(path, `index.${extension}`)
+        ]),
+        VITE_PATHS.join(folder, `_${name}`)
+    ];
+};
+/**
+ * The files a style sheet's text imports: its own folder's, a package's and an address are not this package's.
+ *
+ * @param file - the sheet, absolute.
+ * @param text - its text.
+ * @param exists - whether a file exists.
+ */
+export const sheetImports = (file, text, exists = existsSync) => [
+    ...[...text.matchAll(SHEET_USE)].map((match) => match[1] ?? ""),
+    ...[...text.matchAll(SHEET_IMPORT)].flatMap((statement) => [...(statement[1] ?? "").matchAll(QUOTED)].map((match) => match[1] ?? ""))
+].flatMap((name) => {
+    if (name.includes(":"))
+        return [];
+    const path = VITE_PATHS.join(VITE_PATHS.dirname(file), name);
+    return [sheetCandidates(path).find(exists) ?? path];
+});
+/**
+ * Every relative asset a module's text names as a string.
+ *
+ * @param file - the module, absolute.
+ * @param text - its text.
+ */
+export const assetImports = (file, text) => [...text.matchAll(ASSET_PATH)].map((match) => VITE_PATHS.join(VITE_PATHS.dirname(file), match[1] ?? ""));

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

@@ -1,3 +1,4 @@
+import type { StoryFileCode } from "@forgebook/story-format/source";
 import type { ComponentFiles } from "./adapter.ts";
 import { type DiskCache } from "./diskCache.ts";
 /** A module the plugin answers. */
@@ -5,13 +6,13 @@ type AnsweredModule = {
     code: string;
     moduleType: "js";
 };
-/** A story file's code as the Code tab reads it: each story's `render` text and its coloured HTML, or why it cannot. */
+/**
+ * A story file's code as the Code tab reads it: each story's `render` text and its coloured HTML, or the args it writes
+ * as code, or why it cannot.
+ */
 export type KeptCode = {
     readonly error: string;
-} | Readonly<Record<string, {
-    readonly text: string;
-    readonly html: string;
-}>>;
+} | StoryFileCode;
 /** Whether what a cache file holds is a story file's code. */
 export declare const isKeptCode: (value: unknown) => value is KeptCode;
 /**

package/dist/src/vite/textModules.js

@@ -28,22 +28,27 @@ const valueModule = (value) => ({
 /** Whether what a cache file holds is a story file's code. */
 export const isKeptCode = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
- * Each story's `render` text with its coloured HTML.
+ * Each story's `render` text with its coloured HTML, and each args story's args as written.
  *
  * @remarks
  * The colouring loads the TypeScript compiler, tens of megabytes the server then holds for as long as it runs: only a
  * file with a `render` to colour loads it. A file whose stories are all args has none, and its Code tab writes them
- * from the args (the framework's code writer), so a story's page of a library written that way leaves the compiler to
- * the docs worker; a component's page or a Markdown page still loads it, to colour their examples.
+ * from the args (the framework's code writer, with the args the file writes as code), so a story's page of a library
+ * written that way leaves the compiler to the docs worker; a component's page or a Markdown page still loads it, to
+ * colour their examples.
  *
- * @param code - each story's `render` text, by export name.
+ * @param code - each story's `render` text and written args, by export name.
  */
-const colouredCode = async (code) => {
-    const entries = Object.entries(code);
+const colouredCode = async ({ renders, args }) => {
+    const written = Object.entries(args).map(([name, each]) => [name, { args: each }]);
+    const entries = Object.entries(renders);
     if (entries.length === 0)
-        return {};
+        return Object.fromEntries(written);
     const { highlightCode } = await import("./highlightCode.js");
-    return Object.fromEntries(entries.map(([name, text]) => [name, { text, html: highlightCode(text, "tsx") }]));
+    return Object.fromEntries([
+        ...written,
+        ...entries.map(([name, text]) => [name, { text, html: highlightCode(text, "tsx") }])
+    ]);
 };
 /**
  * A story file's code as the Code tab reads it, what a `?forgebook-code` import answers: each story's `render` text and

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

@@ -6,13 +6,17 @@
  */
 import type { AgentTokenSummary } from "./agent.types.ts";
 import type { AgentAnswer } from "./agentRoutes.ts";
-import { type DesignToken, type ParsedTokens } from "./designTokens.ts";
+import { type DesignToken, type ParsedTokens, type TokenSource } from "./designTokens.ts";
 /** The tokens read, with whether anything names some: a file that cannot be read is named, which is not "no tokens". */
 export type TokenReading = ParsedTokens & {
-    /** Whether the catalogue or a source names a tokens file. */
+    /** Whether there is a system to ask about: a tokens file named, or tokens read from the application. */
     readonly isConfigured: boolean;
     /** The sources whose modules could not be read: whether they hold tokens is not known. */
     readonly unread: readonly string[];
+    /** What the tokens were read from. */
+    readonly sources: readonly TokenSource[];
+    /** What the application's files hold that could not be read without running them. Unlike a problem, it fails nothing. */
+    readonly notes: readonly string[];
 };
 /** A token as a list gives it: no description, and no empty fields, since each one costs an agent's context. */
 export declare const tokenSummary: (token: DesignToken) => AgentTokenSummary;

package/dist/src/vite/tokenAnswers.js

@@ -6,7 +6,7 @@ const TOKENS_LIMIT = 100;
 const NO_TOKENS_FILE = {
     status: 404,
     body: {
-        error: 'This catalogue names no tokens file: `tokens: ["tokens.json"]` in forgebook.config.ts, or on a source it shows'
+        error: 'This catalogue names no tokens file and has none to read: an application with no system of its own (custom properties at the root, Tailwind, components.json), or `tokens: []`. Name a file with `tokens: ["tokens.json"]` in forgebook.config.ts, or on a source it shows'
     }
 };
 /** How many tokens of each type. */
@@ -18,18 +18,19 @@ const typeCounts = (tokens) => {
 };
 /** A token as a list gives it: no description, and no empty fields, since each one costs an agent's context. */
 export const tokenSummary = (token) => {
-    const { name, type, value, modes, deprecated, isThemeOnly } = token;
+    const { name, type, value, modes, deprecated, isThemeOnly, utility } = token;
     return {
         name,
         type,
         value,
         modes,
         ...(deprecated === undefined ? {} : { deprecated }),
-        ...(isThemeOnly === undefined ? {} : { isThemeOnly })
+        ...(isThemeOnly === undefined ? {} : { isThemeOnly }),
+        ...(utility === undefined ? {} : { utility })
     };
 };
 /** The tokens, of a category when one is asked for, up to a limit, with how many there are. */
-const tokensAnswer = ({ tokens, problems, unread, clashes, isConfigured }, params) => {
+const tokensAnswer = ({ tokens, problems, unread, clashes, isConfigured, sources, notes }, params) => {
     const chosen = filteredTokens(tokens, params.get("category") || undefined);
     const limit = Number(params.get("limit") || TOKENS_LIMIT);
     const listed = chosen.slice(0, Number.isFinite(limit) ? limit : TOKENS_LIMIT);
@@ -41,7 +42,9 @@ const tokensAnswer = ({ tokens, problems, unread, clashes, isConfigured }, param
         types: typeCounts(chosen),
         tokens: listed.map(tokenSummary),
         problems: [...unread, ...problems],
-        clashes: clashes.filter((clash) => names.has(clash.name))
+        clashes: clashes.filter((clash) => names.has(clash.name)),
+        sources: sources ?? [],
+        notes: notes ?? []
     };
     return { status: 200, body };
 };
@@ -52,7 +55,8 @@ const tokenAnswer = (reading, params) => {
     const { tokens, clashes } = reading;
     const problems = [...reading.unread, ...reading.problems];
     const name = params.get("name") ?? "";
-    const token = tokens.find((each) => each.name === name);
+    // a custom property's dashes read as an option on a command line, so its name holds without them
+    const token = tokens.find((each) => each.name === name || each.name === `--${name}`);
     if (token === undefined) {
         const read = problems.length === 0 ? "" : ` (and the tokens files have problems: ${problems.join("; ")})`;
         return { status: 404, body: { error: `No token "${name}"${read}` } };
@@ -61,7 +65,7 @@ const tokenAnswer = (reading, params) => {
         schema: 1,
         token,
         problems,
-        clashes: clashes.filter((clash) => clash.name === name)
+        clashes: clashes.filter((clash) => clash.name === token.name)
     };
     return { status: 200, body };
 };

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

@@ -0,0 +1,83 @@
+/**
+ * A generic component's props, written without the type parameters it leaves open: each one shown as its constraint,
+ * else its default, else `unknown`. Used by `propDocs.ts` and `propTypeNotes.ts`.
+ *
+ * @remarks
+ * A prop's text is the one its props type writes (`items: readonly T[]` in `ListProps<T>`), whose `T` is the props
+ * type's parameter, while what bounds it is the component's (`<TItem extends string>(props: ListProps<TItem>)`). The
+ * props type's parameters are followed to the types the component passes (`bindingsOf`), so the constraint shown is
+ * the component's. The replacement is made in the source's text, since the checker's instantiation is not public API.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import type { PropTypeNote } from "../componentDocs.ts";
+/** A prop's type as declared: a type node, or a method's whole signature. */
+export type DeclaredType = ts.TypeNode | ts.MethodSignature;
+/** What the props type's parameters stand for in one component: the types it passes them (`ListProps<TItem>`). */
+export type Bindings = ReadonlyMap<ts.TypeParameterDeclaration, ts.Type>;
+/** What replacing a component's type parameters needs: the checker, and what the props type's parameters stand for. */
+export type Generics = {
+    /** The program's checker. */
+    readonly checker: ts.TypeChecker;
+    /** The props type's parameters, bound to what the component passes. */
+    readonly bindings: Bindings;
+};
+/**
+ * What each type parameter of a props type stands for in this component: an alias's (`type P<T>`) and an interface's,
+ * its bases' included, through unions and intersections.
+ *
+ * @param propsType - the component's props type, as its signature takes it.
+ * @param checker - the program's checker.
+ */
+export declare const bindingsOf: (propsType: ts.Type, checker: ts.TypeChecker) => Bindings;
+/**
+ * Every type reference a node writes, in source order.
+ *
+ * @param node - the node.
+ */
+export declare const referencesIn: (node: ts.Node) => ts.TypeReferenceNode[];
+/**
+ * Whether a prop's declared types name a type parameter of the props type: their text then says `TValue` where a props
+ * type the component instantiates (`BaseProps<string>`) means `string`.
+ *
+ * @param declared - the prop's declared types.
+ * @param checker - the program's checker.
+ */
+export declare const usesTypeParameter: (declared: readonly DeclaredType[], checker: ts.TypeChecker) => boolean;
+/**
+ * A node's source text with each type parameter it uses replaced by what it is shown as.
+ *
+ * @param node - the prop's declared type (or one member of it), or a constraint.
+ * @param generics - the checker and the bindings.
+ * @param seen - the type parameters being replaced.
+ * @returns the text, as `getText()` would give it with the replacements made.
+ */
+export declare const genericFreeText: (node: ts.Node, generics: Generics, seen?: ReadonlySet<ts.TypeParameterDeclaration>) => string;
+/**
+ * The type a prop typed by a type parameter is shown as (`selected?: TKey`): what decides its kind and control. Read
+ * from the checker's type, whose parameter is the component's own.
+ *
+ * @param type - the prop's type, as the component takes it.
+ * @param checker - the program's checker.
+ * @param depth - how many defaults naming another parameter are followed.
+ * @returns the type, or none when the prop's type is not a type parameter.
+ */
+export declare const genericShownType: (type: ts.Type, checker: ts.TypeChecker, depth?: number) => ts.Type | undefined;
+/**
+ * Whether a type, as the component takes it, still holds a type parameter: `readonly TItem[]` in a generic component,
+ * not the `readonly string[]` of a props type it instantiates (`BaseProps<string>`). Through unions, intersections, a
+ * generic's arguments and a function's parameters and result.
+ *
+ * @param type - the prop's type.
+ * @param checker - the program's checker.
+ * @param depth - how many levels are left to look into.
+ */
+export declare const hasTypeParameter: (type: ts.Type, checker: ts.TypeChecker, depth?: number) => boolean;
+/**
+ * The notes of the type parameters a prop's declared types leave open, each once, by the component's name for it.
+ *
+ * @param declared - the prop's declared types.
+ * @param generics - the checker and the bindings.
+ */
+export declare const genericNotes: (declared: readonly DeclaredType[], generics: Generics) => PropTypeNote[];