forgebook 0.3.2 → 0.4.0

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

@@ -0,0 +1,37 @@
+/**
+ * What a file's text imports and what it exports under another name, read with patterns and no parser: the audit's story
+ * coverage (`storyCoverage.ts`) reads every file of a project, single-file components among them, in a moment.
+ *
+ * @remarks
+ * Every pattern is bounded and never matches the same characters two ways, since a project's files can be crafted: a run of
+ * spaces taken both by a `\s+` and by the clause after it would make one file take seconds.
+ *
+ * @module
+ */
+/** One name an import takes: its name in the module (`default`, `*` for all of it) and in the file. */
+export type ImportedName = {
+    /** Its name in the module: `default`, `*` for the whole module, or an export's name. */
+    readonly imported: string;
+    /** Its name in the importing file; empty when it has none (`import("./x")`). */
+    readonly local: string;
+};
+/** What a file imports from one module. */
+export type FileImport = {
+    /** The module, as written. */
+    readonly specifier: string;
+    /** The names taken from it. */
+    readonly names: readonly ImportedName[];
+};
+/**
+ * What a file's text imports: static and dynamic imports and `require`, with the members a namespace is used for.
+ *
+ * @param text - the file's text.
+ */
+export declare const importsOf: (text: string) => FileImport[];
+/**
+ * The names a file exports its own declarations under, when they differ: `export { Root as Dialog }` maps `Dialog` to
+ * `Root`.
+ *
+ * @param text - the file's text.
+ */
+export declare const exportAliasesOf: (text: string) => ReadonlyMap<string, string>;

package/dist/src/vite/importedNames.js

@@ -0,0 +1,138 @@
+/**
+ * What a file's text imports and what it exports under another name, read with patterns and no parser: the audit's story
+ * coverage (`storyCoverage.ts`) reads every file of a project, single-file components among them, in a moment.
+ *
+ * @remarks
+ * Every pattern is bounded and never matches the same characters two ways, since a project's files can be crafted: a run of
+ * spaces taken both by a `\s+` and by the clause after it would make one file take seconds.
+ *
+ * @module
+ */
+/**
+ * An import of values: `import A, { B as C } from "x"`; types only are left out. `import` and its first space are taken
+ * once, and the clause takes everything up to one space before `from`, comments in braces too, but never another
+ * `import`: an `import` with no `from` would otherwise be read again from every later one.
+ */
+const STATIC_IMPORT = /\bimport\s(?!\s*type\s)((?:(?!\bimport\b)[^"';]){1,2000}?)\sfrom\s*["']([^"'\n]{1,500})["']/g;
+/** A dynamic import, which takes the whole module. */
+const DYNAMIC_IMPORT = /\bimport\(\s*["']([^"'\n]{1,500})["']\s*\)/g;
+/** A `require`; what it is given to is read backwards from it, so no pattern is tried at every character before one. */
+const REQUIRE = /\brequire\(\s*["']([^"'\n]{1,500})["']\s*\)/g;
+/** How far back from a `require` its binding is looked for. */
+const MOST_BACK = 2000;
+/** An export of local names, without `from`: `export { Root as Dialog }`. */
+const LOCAL_EXPORT = /\bexport\s{0,20}\{([^{}]{0,2000})\}(?!\s{0,20}from\b)/g;
+/** Comments, which an import's braces may hold. */
+const COMMENT = /\/\*[\s\S]{0,2000}?\*\/|\/\/[^\n]{0,2000}/g;
+/** The names a list in braces takes: `A, B as C, type D`, with `separator` between a name and its new one. */
+const bracedNames = (list, separator) => list
+    .replace(COMMENT, "")
+    .split(",")
+    .flatMap((part) => {
+    const [imported, local] = part.trim().split(separator);
+    if (imported === undefined || imported === "" || imported.startsWith("type "))
+        return [];
+    return [{ imported: imported.trim(), local: (local ?? imported).trim() }];
+});
+/** The names an import's clause takes. */
+const clauseNames = (clause) => {
+    const braces = /\{([^}]*)\}/.exec(clause);
+    const names = bracedNames(braces?.[1] ?? "", /\s+as\s+/);
+    const rest = clause.replace(COMMENT, "").replace(/\{[^}]*\}/, "");
+    const namespace = /\*\s*as\s+([\w$]+)/.exec(rest);
+    if (namespace?.[1] !== undefined)
+        names.push({ imported: "*", local: namespace[1] });
+    const first = /^\s*([\w$]+)\s*(?:,|$)/.exec(rest);
+    if (first?.[1] !== undefined)
+        names.push({ imported: "default", local: first[1] });
+    return names;
+};
+/** A member written after a name, `UI.Button`, starting only where a name starts so each is tried once. */
+const MEMBER = /(?<![\w$.])([A-Za-z_$][\w$]{0,200})\.([A-Za-z_$][\w$]{0,200})/g;
+/**
+ * The members a file writes after each name: `UI.Button` and `<UI.Button>` list `Button` under `UI`. Read in one pass,
+ * since a file can import many namespaces.
+ *
+ * @param text - the file's text.
+ */
+const membersByName = (text) => {
+    const members = new Map();
+    for (const match of text.matchAll(MEMBER)) {
+        const [, owner = "", member = ""] = match;
+        members.set(owner, (members.get(owner) ?? new Set()).add(member));
+    }
+    return members;
+};
+/** An import with the members its namespaces are used for added: a barrel's namespace names what it takes. */
+const withMembers = (found, members) => ({
+    ...found,
+    names: found.names.flatMap((name) => name.imported === "*" && name.local !== ""
+        ? [
+            name,
+            ...[...(members().get(name.local) ?? [])].map((member) => ({ imported: member, local: member }))
+        ]
+        : [name])
+});
+/** A character a name is written with. */
+const NAME_CHARACTER = /[\w$]/;
+/** The name a text ends with, read backwards so a long text costs only its name; empty when it ends otherwise. */
+const trailingName = (text) => {
+    let start = text.length;
+    while (start > 0 && text.length - start < 200 && NAME_CHARACTER.test(text.charAt(start - 1)))
+        start -= 1;
+    return text.slice(start);
+};
+/**
+ * What a `require` takes, from the text before it: `const { A, B: C } =` takes names, `const x =` the whole module as
+ * `x`, and nothing the whole module unnamed.
+ *
+ * @param before - the text just before `require`.
+ */
+const requiredNames = (before) => {
+    const head = before.trimEnd();
+    if (!head.endsWith("="))
+        return [{ imported: "*", local: "" }];
+    const target = head.slice(0, -1).trimEnd();
+    if (target.endsWith("}")) {
+        const open = target.lastIndexOf("{");
+        if (open !== -1)
+            return bracedNames(target.slice(open + 1, -1), /\s*:\s*/);
+    }
+    return [{ imported: "*", local: trailingName(target) }];
+};
+/**
+ * What a file's text imports: static and dynamic imports and `require`, with the members a namespace is used for.
+ *
+ * @param text - the file's text.
+ */
+export const importsOf = (text) => {
+    let read;
+    const members = () => {
+        read ??= membersByName(text);
+        return read;
+    };
+    return [
+        ...[...text.matchAll(STATIC_IMPORT)].map((match) => ({
+            specifier: match[2] ?? "",
+            names: clauseNames(match[1] ?? "")
+        })),
+        ...[...text.matchAll(DYNAMIC_IMPORT)].map((match) => ({
+            specifier: match[1] ?? "",
+            names: [{ imported: "*", local: "" }]
+        })),
+        ...[...text.matchAll(REQUIRE)].map((match) => ({
+            specifier: match[1] ?? "",
+            names: requiredNames(text.slice(Math.max(0, match.index - MOST_BACK), match.index))
+        }))
+    ].map((found) => withMembers(found, members));
+};
+/**
+ * The names a file exports its own declarations under, when they differ: `export { Root as Dialog }` maps `Dialog` to
+ * `Root`.
+ *
+ * @param text - the file's text.
+ */
+export const exportAliasesOf = (text) => new Map([...text.matchAll(LOCAL_EXPORT)]
+    .flatMap((match) => bracedNames(match[1] ?? "", /\s+as\s+/))
+    .filter(({ imported, local }) => imported !== local)
+    .map(({ imported, local }) => [local, imported]));

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

@@ -59,3 +59,9 @@ export declare const heightOf: (fields: Fields) => number | undefined | Error;
 export declare const designOf: (fields: Fields) => FigmaLink | undefined | string | Error;
 /** `parameters.docs.description.<kind>`, when written as a plain string. */
 export declare const docsDescription: (fields: Fields, kind: "story" | "component") => string | undefined;
+/**
+ * `parameters.status`, as the status addons of Storybook write it (`"beta"`, `{ type: "beta" }`, `{ type: ["beta"] }`),
+ * read as tags so a catalogue moved from Storybook keeps its statuses: `undefined` when none. Never a problem: the
+ * parameter is another tool's, so a value written otherwise or by code is left alone.
+ */
+export declare const statusTagsOf: (fields: Fields) => readonly string[] | undefined;

package/dist/src/vite/indexFields.js

@@ -5,6 +5,7 @@
  *
  * @module
  */
+import { TOOL_TAGS } from "../storyTagNames.js";
 import { figmaLink } from "./figmaLink.js";
 /**
  * An expression without the TypeScript wrappers a meta is often written with (`satisfies Meta<…>`, `as Meta`).
@@ -147,3 +148,23 @@ export const docsDescription = (fields, kind) => {
     const text = propertyValue(description, kind);
     return text?.type === "Literal" && typeof text.value === "string" ? text.value : undefined;
 };
+/** The strings an expression writes plainly: a string, or a list of strings; none for anything else. */
+const plainStrings = (expression) => {
+    if (expression?.type === "Literal")
+        return typeof expression.value === "string" ? [expression.value] : undefined;
+    if (expression?.type !== "ArrayExpression")
+        return undefined;
+    const strings = expression.elements.flatMap((element) => element?.type === "Literal" && typeof element.value === "string" ? [element.value] : []);
+    return strings.length === expression.elements.length ? strings : undefined;
+};
+/**
+ * `parameters.status`, as the status addons of Storybook write it (`"beta"`, `{ type: "beta" }`, `{ type: ["beta"] }`),
+ * read as tags so a catalogue moved from Storybook keeps its statuses: `undefined` when none. Never a problem: the
+ * parameter is another tool's, so a value written otherwise or by code is left alone.
+ */
+export const statusTagsOf = (fields) => {
+    const status = parameter(fields, "status");
+    const written = status?.type === "ObjectExpression" ? propertyValue(status, "type") : status;
+    // a status names what a component is: never a tool's tag, which would list or test a story its meta left out
+    return plainStrings(written)?.filter((tag) => tag !== "" && !tag.startsWith("!") && !TOOL_TAGS.has(tag));
+};

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

@@ -6,7 +6,8 @@
  * The sidebar lists every story before any is loaded, so the index comes from the code itself, parsed with Vite's
  * parser (the same files Vite compiles). It reads a meta written inline or as a constant (`export default meta`,
  * `export { meta as default }`), `includeStories`, `excludeStories`, `__namedExportsOrder`, the meta's and the
- * stories' `tags`, the TSDoc above a story, and `parameters.docs.description`.
+ * stories' `tags` (with `parameters.status`, the status addons' way of writing one), the TSDoc above a story, and
+ * `parameters.docs.description`.
  *
  * Every named export the meta lets in is a story, as Storybook's indexer has it, whatever writes its value: an object
  * (CSF 3), a function with its properties assigned after it (CSF 2: `A.storyName`, `A.parameters`), a template bound
@@ -33,6 +34,12 @@ export type IndexOptions = {
     /** The title from the file's path (`Inputs/Select`); none when the file's place gives none. */
     readonly autoTitle?: string;
 };
+/**
+ * Tags as Storybook combines them: the meta's, then the story's, a `!name` taking `name` away.
+ *
+ * @param lists - the tag lists, outermost first.
+ */
+export declare const combinedTags: (lists: readonly (readonly string[] | undefined)[]) => readonly string[];
 /**
  * A story file's meta object, as the index reads it: inline or a constant of the file, exported by default or by name.
  *

package/dist/src/vite/indexStoryFile.js

@@ -6,7 +6,8 @@
  * The sidebar lists every story before any is loaded, so the index comes from the code itself, parsed with Vite's
  * parser (the same files Vite compiles). It reads a meta written inline or as a constant (`export default meta`,
  * `export { meta as default }`), `includeStories`, `excludeStories`, `__namedExportsOrder`, the meta's and the
- * stories' `tags`, the TSDoc above a story, and `parameters.docs.description`.
+ * stories' `tags` (with `parameters.status`, the status addons' way of writing one), the TSDoc above a story, and
+ * `parameters.docs.description`.
  *
  * Every named export the meta lets in is a story, as Storybook's indexer has it, whatever writes its value: an object
  * (CSF 3), a function with its properties assigned after it (CSF 2: `A.storyName`, `A.parameters`), a template bound
@@ -27,10 +28,11 @@
  * @module
  */
 import { indexedParameters } from "./indexedParameters.js";
-import { controlsOf, designOf, docsDescription, groupOf, heightOf, objectFields, parameter, propertyValue, propGroupsOf, stringField, stringListOf, unwrapped } from "./indexFields.js";
-import { moduleName, namedExports } from "./storyExports.js";
+import { controlsOf, designOf, docsDescription, groupOf, heightOf, objectFields, parameter, propertyValue, propGroupsOf, statusTagsOf, stringField, stringListOf } from "./indexFields.js";
+import { lineAndColumn } from "./lineAndColumn.js";
 import { parseStoryFile } from "./storyParse.js";
 import { playField } from "./storyPlay.js";
+import { metaObject, objectOf, storyExports, topLevelOf } from "./storyTopLevel.js";
 /**
  * The first sentence of the TSDoc right above a statement, without its tags; `undefined` when there is none.
  *
@@ -60,7 +62,7 @@ const leadingSentence = (text, comments, start) => {
  *
  * @param lists - the tag lists, outermost first.
  */
-const combinedTags = (lists) => {
+export const combinedTags = (lists) => {
     const tags = new Set();
     for (const tag of lists.flatMap((list) => list ?? [])) {
         if (tag.startsWith("!")) {
@@ -101,13 +103,14 @@ const identityOf = (own) => {
 };
 /**
  * What the index reads of one story: its own id (`parameters.__id`), its name (`name`, or CSF 2's `storyName`),
- * controls, group, height, design, whether it is the demo, and its tags under the meta's.
+ * controls, group, height, design, whether it is the demo, and its tags under the meta's. A story's
+ * `parameters.status` replaces the meta's, as a story's parameter does.
  *
  * @param fields - the story's fields: its own, for its name and id, and all it has, for the rest.
- * @param metaTags - the meta's tags.
+ * @param meta - the meta's tags and its `parameters.status`, as written.
  * @param notes - the file's notes, which a design left out adds to.
  */
-const storyFields = ({ own, fields }, metaTags, notes) => {
+const storyFields = ({ own, fields }, meta, notes) => {
     const controls = controlsOf(fields);
     if (controls instanceof Error)
         return controls;
@@ -125,7 +128,7 @@ const storyFields = ({ own, fields }, metaTags, notes) => {
     const ownTags = stringListOf(fields, "tags");
     if (ownTags instanceof Error)
         return ownTags;
-    const tags = combinedTags([metaTags, ownTags]);
+    const tags = combinedTags([meta.tags, statusTagsOf(fields) ?? meta.status, ownTags]);
     const main = parameter(fields, "main");
     const flags = indexedParameters(fields);
     if (flags instanceof Error)
@@ -141,68 +144,6 @@ const storyFields = ({ own, fields }, metaTags, notes) => {
         ...(tags.length > 0 ? { tags } : {})
     };
 };
-/**
- * The property a top-level statement assigns to a name, when it assigns one.
- *
- * @param statement - the statement.
- */
-const assignedProperty = (statement) => {
-    if (statement.type !== "ExpressionStatement")
-        return undefined;
-    const { expression } = statement;
-    if (expression.type !== "AssignmentExpression" || expression.left.type !== "MemberExpression")
-        return undefined;
-    const { object, property } = expression.left;
-    if (object.type !== "Identifier" || property.type !== "Identifier")
-        return undefined;
-    return { name: object.name, property: property.name, value: unwrapped(expression.right) };
-};
-/**
- * The constants a top-level statement declares with a value, exported or not.
- *
- * @param statement - the statement.
- */
-const declaredBy = (statement) => {
-    const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-    if (declaration?.type !== "VariableDeclaration")
-        return [];
-    return declaration.declarations.flatMap(({ id, init }) => id.type === "Identifier" && init !== null ? [{ name: id.name, value: unwrapped(init) }] : []);
-};
-/**
- * The file's top level: its constants, exported or not, and the properties assigned to names.
- *
- * @param program - the parsed file.
- */
-const topLevelOf = (program) => {
-    const values = new Map();
-    const assigned = new Map();
-    for (const statement of program.body) {
-        for (const declared of declaredBy(statement))
-            values.set(declared.name, declared.value);
-        const property = assignedProperty(statement);
-        if (property === undefined)
-            continue;
-        const properties = assigned.get(property.name) ?? new Map();
-        properties.set(property.property, property.value);
-        assigned.set(property.name, properties);
-    }
-    return { values, assigned };
-};
-/**
- * The object a value is, or the one the constants it names lead to (`export const B = A`); `undefined` for any other
- * value, or for names that lead back to themselves.
- *
- * @param top - the file's top level.
- * @param value - the value.
- * @param seen - the names followed so far.
- */
-const objectOf = (top, value, seen = new Set()) => {
-    if (value?.type === "ObjectExpression")
-        return value;
-    if (value?.type !== "Identifier" || seen.has(value.name))
-        return undefined;
-    return objectOf(top, top.values.get(value.name), new Set([...seen, value.name]));
-};
 /**
  * A story's fields, by the export that names it: what is assigned to it after its declaration (`A.storyName = "…"`),
  * else the object its value is or names. A story from another file has none.
@@ -221,73 +162,6 @@ const storyFieldsOf = (top, named) => {
     const read = (from) => (name) => assigned?.get(name) ?? (from === undefined ? undefined : propertyValue(from, name));
     return { own: read(declared), fields: read(object) };
 };
-/**
- * Whether an export is a story, as the meta's `includeStories` and `excludeStories` say (a list of names or a regular
- * expression, written plainly).
- *
- * @param meta - the meta's fields.
- * @param exportName - the export.
- */
-const isIncluded = (meta, exportName) => {
-    const matches = (name) => {
-        const filter = meta(name);
-        if (filter?.type === "ArrayExpression")
-            return filter.elements.some((element) => element?.type === "Literal" && element.value === exportName);
-        if (filter?.type === "Literal" && "regex" in filter && filter.regex !== undefined)
-            return new RegExp(filter.regex.pattern, filter.regex.flags).test(exportName);
-        return undefined;
-    };
-    return matches("includeStories") !== false && matches("excludeStories") !== true;
-};
-/**
- * The order `__namedExportsOrder` writes, when the file writes one plainly.
- *
- * @param top - the file's top level.
- */
-const exportsOrder = (top) => {
-    const order = top.values.get("__namedExportsOrder");
-    if (order?.type !== "ArrayExpression")
-        return undefined;
-    return order.elements.flatMap((element) => element?.type === "Literal" && typeof element.value === "string" ? [element.value] : []);
-};
-/**
- * The meta exported by name (`export { meta as default }`), when it is a constant of the file written as an object.
- *
- * @param program - the parsed file.
- * @param top - the file's top level.
- */
-const namedMeta = (program, top) => {
-    for (const statement of program.body) {
-        if (statement.type !== "ExportNamedDeclaration" || statement.source !== null)
-            continue;
-        const specifier = statement.specifiers.find((each) => moduleName(each.exported) === "default");
-        if (specifier === undefined)
-            continue;
-        const value = top.values.get(moduleName(specifier.local));
-        return value?.type === "ObjectExpression" ? value : undefined;
-    }
-    return undefined;
-};
-/**
- * The meta's object: the default export, inline or a constant of the file (`export default meta`,
- * `export { meta as default }`).
- *
- * @param program - the parsed file.
- * @param top - the file's top level.
- */
-const metaObject = (program, top) => {
-    const meta = program.body.find((statement) => statement.type === "ExportDefaultDeclaration");
-    if (meta === undefined)
-        return namedMeta(program, top);
-    const { declaration } = meta;
-    if (declaration.type === "FunctionDeclaration" ||
-        declaration.type === "ClassDeclaration" ||
-        declaration.type === "TSInterfaceDeclaration")
-        return undefined;
-    const expression = unwrapped(declaration);
-    const value = expression.type === "Identifier" ? top.values.get(expression.name) : expression;
-    return value?.type === "ObjectExpression" ? value : undefined;
-};
 /**
  * A story file's meta object, as the index reads it: inline or a constant of the file, exported by default or by name.
  *
@@ -384,21 +258,6 @@ const metaFieldsOf = (meta, notes) => {
         ...(description === undefined ? {} : { description })
     };
 };
-/**
- * The exports that are stories, in the order of `__namedExportsOrder` when the file writes one, else of the file.
- *
- * @param program - the parsed file.
- * @param top - the file's top level.
- * @param meta - the meta's fields, for `includeStories` and `excludeStories`.
- */
-const storyExports = (program, top, meta) => {
-    const exported = namedExports(program).filter(({ exportName }) => exportName !== "__namedExportsOrder" && isIncluded(meta, exportName));
-    const order = exportsOrder(top);
-    if (order === undefined)
-        return exported;
-    const rank = (name) => (order.includes(name) ? order.indexOf(name) : order.length);
-    return [...exported].sort((first, second) => rank(first.exportName) - rank(second.exportName));
-};
 /**
  * The index of one story file.
  *
@@ -410,8 +269,11 @@ const storyExports = (program, top, meta) => {
 export const indexStoryFile = (file, text, options = {}) => {
     const { program, comments, errors } = parseStoryFile(file, text);
     const [error] = errors;
-    if (error !== undefined)
-        return `${file} does not parse: ${error.message}`;
+    if (error !== undefined) {
+        const [label] = error.labels;
+        const place = label === undefined ? file : `${file}:${lineAndColumn(text, label.start)}`;
+        return `${place} does not parse: ${error.message}`;
+    }
     const top = topLevelOf(program);
     const metaNode = metaObject(program, top);
     if (metaNode === undefined)
@@ -420,9 +282,10 @@ export const indexStoryFile = (file, text, options = {}) => {
     const title = titleOf(meta, options);
     if (typeof title === "string")
         return `${file}: ${title}`;
-    const metaTags = stringListOf(meta, "tags");
-    if (metaTags instanceof Error)
-        return `${file}: the meta's ${metaTags.message}`;
+    const writtenTags = stringListOf(meta, "tags");
+    if (writtenTags instanceof Error)
+        return `${file}: the meta's ${writtenTags.message}`;
+    const metaTags = { tags: writtenTags, status: statusTagsOf(meta) };
     const stories = [];
     const storyNotes = [];
     for (const named of storyExports(program, top, meta)) {
@@ -442,10 +305,12 @@ export const indexStoryFile = (file, text, options = {}) => {
     if (metaFields instanceof Error)
         return `${file}: the meta's ${metaFields.message}`;
     const notes = [...title.notes, ...metaNotes, ...storyNotes];
+    const tags = combinedTags([metaTags.tags, metaTags.status]);
     return {
         title: title.title,
         stories,
         ...metaFields,
+        ...(tags.length > 0 ? { tags } : {}),
         ...(notes.length > 0 ? { notes } : {})
     };
 };

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

@@ -0,0 +1,33 @@
+/**
+ * Where an application draws a JSX component, read from its program with the TypeScript checker (no code runs): each
+ * element whose tag is the component, with the props it gives a literal value. `forgebook new` takes its values from
+ * them, so a first story shows the component as the application uses it rather than with a prop's name for its text.
+ *
+ * @remarks
+ * Shared by the frameworks whose components are functions of their props (React, Preact, Solid). The program is the
+ * component's configuration's, read whole. Story files, tests and declaration files are left out: they are not the
+ * application. A value is kept only when it is a literal (a string, a number, `true`, `false`, `null`, a list or an
+ * object of them); one that depends on the caller's state would not mean anything in a story. A child that is plain text
+ * is `children`.
+ *
+ * @module
+ */
+import ts from "typescript-6";
+import type { ExtractCallSites } from "./adapter.ts";
+/**
+ * An expression as code a story can hold, when it is a literal: shared with the frameworks that read their templates'
+ * bindings as expressions (Vue's `:size="3"`).
+ *
+ * @param node - the expression.
+ * @param depth - how deep in a list or an object it is.
+ * @returns the code; none when it is not a literal.
+ */
+export declare const literalExpressionCode: (node: ts.Expression, depth?: number) => string | undefined;
+/**
+ * Where the application draws a component a file exports.
+ *
+ * @param file - the component's file, absolute.
+ * @param name - the export's name (`default` for a default export).
+ * @returns the call sites; a message when the file or the export cannot be read.
+ */
+export declare const jsxCallSites: ExtractCallSites;