@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/compiler-ir/ir.js

@@ -0,0 +1,67 @@
+import { evidenceIdSchema, evidenceSchema, factPathSchema, jsonValueSchema, sourceIdSchema, sourceTypeSchema, sourceVersionSchema } from "../contract/index.js";
+import { diagnosticSchema } from "../shared/index.js";
+import { z } from "zod";
+export const IR_VERSION = "1.3.0";
+/**
+ * Kinds up to `story` model design-system content. `package`, `export`, `config` and `token-file` were
+ * added in IR 1.1.0 so project discovery can be represented honestly without calling an export a component.
+ * `story-group` (a CSF `meta`: title, component, shared args and argTypes) was added in IR 1.2.0.
+ * `module` (a unit that declares, imports and exports other entities, such as an Angular NgModule) was added in IR 1.3.0.
+ */
+export const irEntityKindSchema = z.enum([
+    "component",
+    "token",
+    "theme",
+    "pattern",
+    "guideline",
+    "constraint",
+    "doc-page",
+    "story",
+    "package",
+    "export",
+    "config",
+    "token-file",
+    "story-group",
+    "module"
+]);
+/** Something a source can talk about. `ref` is local to one IR document, never a contract id. */
+export const irEntitySchema = z.strictObject({
+    ref: z.string().min(1),
+    kind: irEntityKindSchema,
+    name: z.string().min(1)
+});
+/**
+ * One claim by one source: (subject, path) has `value`. Paths use the contract's fact-path grammar,
+ * for example `props.size.default`; framework-specific detail goes under `extensions.<namespace>`.
+ * `origin` is only what an adapter can honestly say. Adapters cannot emit `inferred` or `approved`.
+ */
+export const irFactSchema = z.strictObject({
+    subject: z.string().min(1),
+    path: factPathSchema,
+    value: jsonValueSchema,
+    origin: z.enum(["extracted", "authored"]),
+    evidenceIds: z.array(evidenceIdSchema).min(1),
+    completeness: z.enum(["complete", "partial", "unknown"]).optional()
+});
+export const irSourceSchema = z.strictObject({
+    id: sourceIdSchema,
+    type: sourceTypeSchema.exclude(["patterns"]),
+    location: z.string().min(1),
+    version: sourceVersionSchema.optional(),
+    /** Hash of the source inputs read, so an unchanged source can be skipped on recompile. */
+    inputHash: z.string().regex(/^[0-9a-f]{64}$/),
+    adapter: z.strictObject({ name: z.string().min(1), version: z.string().min(1) })
+});
+export const irDocumentSchema = z.strictObject({
+    irVersion: z.literal(IR_VERSION),
+    source: irSourceSchema,
+    /** Fact-path patterns this adapter can supply; `*` matches exactly one path segment. */
+    capabilities: z.array(z.string().min(1)),
+    /** `partial` and `failed` mean absent facts are not evidence that something does not exist. */
+    completeness: z.enum(["complete", "partial", "failed"]),
+    entities: z.array(irEntitySchema),
+    facts: z.array(irFactSchema),
+    evidence: z.array(evidenceSchema),
+    diagnostics: z.array(diagnosticSchema)
+});
+//# sourceMappingURL=ir.js.map

package/dist/compiler-ir/json-schema.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import { irDocumentSchema } from "./ir.js";
+export function irJsonSchemas() {
+    return { "ir-v1.schema.json": { title: "Invariant IR document v1", ...z.toJSONSchema(irDocumentSchema) } };
+}
+//# sourceMappingURL=json-schema.js.map

package/dist/compiler-ir/validate.js

@@ -0,0 +1,116 @@
+import { computeEvidenceId } from "../contract/index.js";
+import { canonicalStringify, hashJson, sortDiagnostics } from "../shared/index.js";
+import { IR_VERSION, irDocumentSchema } from "./ir.js";
+export function parseIrDocument(input) {
+    const version = typeof input === "object" && input !== null ? input.irVersion : undefined;
+    if (typeof version === "string" && version.split(".")[0] !== IR_VERSION.split(".")[0]) {
+        return {
+            ok: false,
+            diagnostics: [
+                {
+                    code: "ir.unsupported-version",
+                    severity: "error",
+                    message: `IR version ${version} is not supported; this build reads ${IR_VERSION}`
+                }
+            ]
+        };
+    }
+    const result = irDocumentSchema.safeParse(input);
+    return result.success
+        ? { ok: true, value: result.data }
+        : { ok: false, diagnostics: schemaDiagnostics(result.error) };
+}
+/** Sorts every collection so the same logical document always serializes identically. */
+export function canonicalizeIrDocument(doc) {
+    return {
+        ...doc,
+        capabilities: [...new Set(doc.capabilities)].sort(),
+        entities: [...doc.entities].sort((a, b) => cmp(a.ref, b.ref)),
+        facts: [...doc.facts].sort((a, b) => cmp(a.subject, b.subject) ||
+            cmp(a.path, b.path) ||
+            cmp(canonicalStringify(a.value), canonicalStringify(b.value))),
+        evidence: [...doc.evidence].sort((a, b) => cmp(a.id, b.id)),
+        diagnostics: sortDiagnostics(doc.diagnostics)
+    };
+}
+/**
+ * Content hash of an IR document excluding evidence capture times, so re-running extraction on
+ * unchanged inputs yields the same hash even though `capturedAt` differs.
+ */
+export function computeIrContentHash(doc) {
+    const canonical = canonicalizeIrDocument(doc);
+    return hashJson({
+        ...canonical,
+        evidence: canonical.evidence.map(({ capturedAt: _capturedAt, ...rest }) => rest)
+    });
+}
+export function serializeIrDocument(doc) {
+    return `${canonicalStringify(canonicalizeIrDocument(doc), 2)}\n`;
+}
+/** `*` matches exactly one path segment. */
+export function matchesCapability(pattern, path) {
+    const p = pattern.split(".");
+    const s = path.split(".");
+    if (p.length > s.length)
+        return false;
+    // A capability covers its subtree: `props.*.default` covers `props.size.default.text`.
+    return p.every((segment, i) => segment === "*" || segment === s[i]);
+}
+/** Semantic validation of an IR document. Never throws; returns diagnostics. */
+export function verifyIrDocument(doc) {
+    const found = [];
+    const sourceId = doc.source.id;
+    const add = (severity, code, message) => {
+        found.push({ code, severity, message, sourceId });
+    };
+    const refs = new Set();
+    for (const entity of doc.entities) {
+        if (refs.has(entity.ref))
+            add("error", "ir.duplicate-entity-ref", `Duplicate entity ref ${entity.ref}`);
+        refs.add(entity.ref);
+    }
+    const evidenceIds = new Set();
+    for (const evidence of doc.evidence) {
+        if (evidenceIds.has(evidence.id))
+            add("error", "ir.duplicate-evidence", `Duplicate evidence ${evidence.id}`);
+        evidenceIds.add(evidence.id);
+        if (computeEvidenceId(evidence) !== evidence.id)
+            add("error", "ir.evidence-id-mismatch", `Evidence ${evidence.id} id does not match its content`);
+        if (evidence.sourceId !== sourceId)
+            add("error", "ir.evidence-source-mismatch", `Evidence ${evidence.id} belongs to source ${evidence.sourceId}, not ${sourceId}`);
+        if (evidence.method === "llm-assisted") {
+            add("error", "ir.llm-evidence", `Evidence ${evidence.id} is LLM-assisted; adapters must be deterministic (model output belongs to the semantic engine)`);
+        }
+    }
+    const seen = new Map();
+    for (const fact of doc.facts) {
+        if (!refs.has(fact.subject))
+            add("error", "ir.unknown-subject", `Fact '${fact.path}' targets unknown entity ${fact.subject}`);
+        for (const id of fact.evidenceIds) {
+            if (!evidenceIds.has(id))
+                add("error", "ir.unknown-evidence", `Fact ${fact.subject} '${fact.path}' cites missing evidence ${id}`);
+        }
+        if (!doc.capabilities.some((pattern) => matchesCapability(pattern, fact.path))) {
+            add("warning", "ir.undeclared-capability", `Fact ${fact.subject} '${fact.path}' is outside the adapter's declared capabilities`);
+        }
+        const key = `${fact.subject}\u0000${fact.path}`;
+        const value = canonicalStringify(fact.value);
+        const previous = seen.get(key);
+        if (previous !== undefined && previous !== value) {
+            add("warning", "ir.conflicting-facts", `Source disagrees with itself at ${fact.subject} '${fact.path}'`);
+        }
+        seen.set(key, value);
+    }
+    return sortDiagnostics(found);
+}
+function schemaDiagnostics(error) {
+    return sortDiagnostics(error.issues.map((issue) => ({
+        code: "ir.invalid-schema",
+        severity: "error",
+        message: `${issue.path.reduce((acc, part) => (typeof part === "number" ? `${acc}[${part}]` : `${acc}.${String(part)}`), "$")}: ${issue.message}`
+    })));
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+//# sourceMappingURL=validate.js.map

package/dist/compiler-react/adapter.js

@@ -0,0 +1,147 @@
+import { DEFAULT_IGNORED_DIRS, hashText, IrBuilder, walk } from "../compiler-core/index.js";
+import { hashJson } from "../shared/index.js";
+import { analyzePackage } from "./analyze.js";
+import { CAPABILITIES, emitComponent } from "./emit.js";
+export const ADAPTER_ID = "react";
+export const ADAPTER_VERSION = "0.1.0";
+const SOURCE_FILE = /\.(?:[cm]?[jt]sx?|css)$|(?:^|\/)tsconfig[^/]*\.json$/;
+const MAX_FILE_BYTES = 1_000_000;
+/**
+ * React/TypeScript adapter. For every workspace package that declares React, it type-checks the
+ * package's own files (never third-party code, never executing anything) and emits one IR document
+ * with the components its entry points export: props, defaults, variants, slots, accessibility,
+ * styling references, composition, and static usage.
+ */
+export const reactAdapter = {
+    id: ADAPTER_ID,
+    version: ADAPTER_VERSION,
+    type: "react",
+    async discover({ fs, project }) {
+        const sources = [];
+        const used = new Set();
+        for (const pkg of project.packages.filter((p) => p.frameworks.some((f) => f.name === "react"))) {
+            const others = project.packages.filter((p) => p.id !== pkg.id && p.dir !== "." && (pkg.dir === "." || p.dir.startsWith(`${pkg.dir}/`)));
+            const { files, hashes } = await readPackageFiles(fs, pkg, others);
+            const slug = (pkg.name ?? pkg.dir)
+                .toLowerCase()
+                .replace(/[^a-z0-9._-]+/g, "-")
+                .replace(/^[^a-z0-9]+|[-.]+$/g, "") || "root";
+            let id = `react-${slug}`;
+            for (let n = 2; used.has(id); n++)
+                id = `react-${slug}-${n}`;
+            used.add(id);
+            sources.push({
+                id,
+                type: "react",
+                location: pkg.dir,
+                config: {
+                    packageId: pkg.id,
+                    files: [...files.keys()],
+                    tailwind: pkg.dependencies.some((d) => d.name === "tailwindcss") ||
+                        project.tokenFiles.some((f) => f.kind === "tailwind-config" && f.package === pkg.id)
+                },
+                ...(pkg.version ? { version: { kind: "package-version", value: pkg.version } } : {}),
+                inputHash: hashJson(hashes)
+            });
+        }
+        return { sources, diagnostics: [] };
+    },
+    async extract({ fs, project, source, clock }, config) {
+        const pkg = project.packages.find((p) => p.id === config.packageId);
+        if (!pkg)
+            throw new Error(`Package ${config.packageId} is not in the project discovery`);
+        const files = new Map();
+        for (const path of config.files)
+            files.set(path, await fs.readFile(path));
+        const analysis = analyzePackage({
+            ...(pkg.name ? { packageName: pkg.name } : {}),
+            packageDir: pkg.dir,
+            entryPoints: pkg.entryPoints,
+            files,
+            ...(pkg.dir.split("/").includes("node_modules") ? { typeFiles: await readTypeFiles(fs) } : {}),
+            tailwind: config.tailwind
+        });
+        const builder = new IrBuilder({
+            source: {
+                id: source.id,
+                type: source.type,
+                location: source.location,
+                ...(source.version ? { version: source.version } : {}),
+                inputHash: source.inputHash,
+                adapter: { name: ADAPTER_ID, version: ADAPTER_VERSION }
+            },
+            extractor: { name: "react-ts", version: ADAPTER_VERSION },
+            capabilities: CAPABILITIES,
+            clock
+        });
+        for (const component of analysis.components)
+            emitComponent(builder, component, pkg);
+        for (const d of analysis.diagnostics)
+            builder.diagnostic(d);
+        const partial = analysis.components.some((c) => !c.props.complete) ||
+            analysis.diagnostics.some((d) => d.code === "react.entry-not-analyzed");
+        return { ir: builder.build(partial ? "partial" : "complete") };
+    },
+    async validate({ ir }) {
+        return ir.entities.length === 0
+            ? [
+                {
+                    code: "react.no-components",
+                    severity: "info",
+                    message: `No React components were found in the entry points of ${ir.source.id}`,
+                    sourceId: ir.source.id
+                }
+            ]
+            : [];
+    }
+};
+/**
+ * Declaration files of everything installed next to an installed package (`@types/react`, `csstype`, the primitives a
+ * library builds on). Without them a props type that mentions any of them resolves to nothing, and so does the whole
+ * intersection it is part of. They are read for type resolution only: nothing declared in them is a project node.
+ */
+async function readTypeFiles(fs) {
+    const files = new Map();
+    if (!(await fs.exists("node_modules")))
+        return files;
+    const walked = await walk(fs, {
+        ignoreDirs: new Set([".invariant", ".bin", ".cache"]),
+        maxFiles: 60_000,
+        start: "node_modules"
+    });
+    let bytes = 0;
+    for (const path of walked.files) {
+        if (!/\.d\.[cm]?ts$|(?:^|\/)package\.json$/.test(path))
+            continue;
+        const text = await fs.readFile(path);
+        if (text.length > 5_000_000 || bytes + text.length > 60_000_000)
+            continue;
+        bytes += text.length;
+        files.set(path, text);
+    }
+    return files;
+}
+async function readPackageFiles(fs, pkg, nested) {
+    // An installed package (opted in through a declaration root) keeps its declaration files in build output.
+    const installed = pkg.dir.split("/").includes("node_modules");
+    const walked = await walk(fs, {
+        ignoreDirs: new Set(installed
+            ? DEFAULT_IGNORED_DIRS.filter((d) => !["dist", "build", "out"].includes(d))
+            : DEFAULT_IGNORED_DIRS),
+        maxFiles: 20_000,
+        start: pkg.dir
+    });
+    const files = new Map();
+    const hashes = [];
+    for (const path of walked.files) {
+        if (!SOURCE_FILE.test(path) || nested.some((n) => path === n.dir || path.startsWith(`${n.dir}/`)))
+            continue;
+        const text = await fs.readFile(path);
+        if (text.length > MAX_FILE_BYTES)
+            continue;
+        files.set(path, text);
+        hashes.push([path, hashText(text)]);
+    }
+    return { files, hashes };
+}
+//# sourceMappingURL=adapter.js.map

package/dist/compiler-react/analyze.js

@@ -0,0 +1,199 @@
+import { createAnalysis, declarationOf, isProjectNode, jsxTargetDeclaration, lineOf, posix, relativeFileOf, resolveSymbol, subTarget, tsconfigPaths, unwrap } from "../compiler-core/index.js";
+import ts from "typescript";
+import { accessibilityOf, docsOf, slotsOf } from "./behavior.js";
+import { classifyCompound, classifyDeclaration } from "./detect.js";
+import { extractProps } from "./props.js";
+import { stylingOf } from "./styling.js";
+import { analyzeUsage } from "./usage.js";
+import { variantsOf } from "./variants.js";
+const NON_SOURCE = /\.(?:test|spec|stories)\.[cm]?[jt]sx?$|(?:^|\/)__(?:tests|mocks)__\//;
+/** Finds the package's public React components (exports of its entry points) and analyzes each. */
+export function analyzePackage(input) {
+    const diagnostics = [];
+    const analysis = createAnalysis(input.files, {
+        paths: tsconfigPaths(input.files, input.packageDir),
+        ...(input.typeFiles ? { externalFiles: input.typeFiles } : {})
+    });
+    const { checker } = analysis;
+    const note = (severity, code, message, node) => {
+        const file = node ? relativeFileOf(analysis, node) : undefined;
+        diagnostics.push({
+            code,
+            severity,
+            message,
+            ...(file && node ? { location: { path: file, line: lineOf(node) } } : {})
+        });
+    };
+    // 1. Public candidates: whatever the entry points export.
+    const candidates = new Map();
+    for (const entry of input.entryPoints) {
+        const sf = entry.file ? analysis.sourceFile(entry.file) : undefined;
+        if (!entry.file || entry.resolution === "unresolved" || !sf) {
+            // Stylesheets, JSON and the like are entries a component library lists but not modules to analyze.
+            if (entry.file && /\.[cm]?[jt]sx?$/.test(entry.file))
+                note("warning", "react.entry-not-analyzed", `Entry ${entry.subpath} (${entry.file}) is not a TypeScript or JavaScript module in the analyzed files`);
+            continue;
+        }
+        const moduleSymbol = checker.getSymbolAtLocation(sf);
+        if (!moduleSymbol)
+            continue;
+        for (const exported of checker.getExportsOfModule(moduleSymbol)) {
+            const resolved = resolveSymbol(checker, exported);
+            const decl = declarationOf(resolved);
+            if (!decl || !isProjectNode(analysis, decl))
+                continue;
+            const result = classifyDeclaration(checker, decl, exported.name === "default" ? baseName(decl) : exported.name);
+            if (!result) {
+                // A declaration file's `{ Root: typeof X }` object: its members are the components.
+                const compound = classifyCompound(checker, decl, exported.name === "default" ? baseName(decl) : exported.name);
+                if (compound) {
+                    for (const { key, candidate } of compound) {
+                        const displayName = `${exported.name}.${key}`;
+                        const existingChild = candidates.get(candidate.decl);
+                        const exportEntry = { subpath: entry.subpath, name: displayName };
+                        if (existingChild)
+                            existingChild.exports.push(exportEntry);
+                        else
+                            candidates.set(candidate.decl, { ...candidate, displayName, exports: [exportEntry] });
+                    }
+                    continue;
+                }
+                if (looksLikeFactoryComponent(decl, exported.name)) {
+                    note("info", "react.unclassified-export", `${exported.name} is a Pascal-case export created by a function call, so it could not be classified as a component statically`, decl);
+                }
+                continue;
+            }
+            if ("hoc" in result) {
+                note("info", "react.higher-order-component", `${result.name} returns a component (a higher-order component) and was not analyzed`, result.node);
+                continue;
+            }
+            const key = result.decl;
+            const existing = candidates.get(key);
+            if (existing)
+                existing.exports.push({ subpath: entry.subpath, name: exported.name });
+            else
+                candidates.set(key, { ...result, exports: [{ subpath: entry.subpath, name: exported.name }] });
+        }
+    }
+    // 2. Compound children become components of their own, named `Parent.Child`.
+    const parents = new Map();
+    const children = [];
+    const queue = [...candidates.values()];
+    for (let i = 0; i < queue.length; i++) {
+        const parent = queue[i];
+        for (const sub of parent.subcomponents) {
+            // A declaration file's `Item: (props: P) => JSX.Element` member is its own declaration.
+            const decl = ts.isPropertySignature(sub.target) ? sub.target : subTarget(checker, sub.target);
+            if (!decl)
+                continue;
+            const child = classifyDeclaration(checker, decl, sub.key);
+            if (!child || "hoc" in child || candidates.has(child.decl))
+                continue;
+            const named = { ...child, displayName: `${parent.displayName ?? parent.name}.${sub.key}`, exports: [] };
+            parents.set(named, parent);
+            children.push(named);
+            queue.push(named);
+        }
+    }
+    for (const child of children)
+        candidates.set(child.decl, child);
+    // 3. Per-component facts.
+    const list = [...candidates.values()].sort((a, b) => cmp(`${relOf(analysis, a.decl)}#${a.name}`, `${relOf(analysis, b.decl)}#${b.name}`));
+    const refs = new Map();
+    const usedRefs = new Set();
+    for (const c of list) {
+        let ref = `react:${relOf(analysis, c.decl)}#${c.name}`;
+        if (usedRefs.has(ref))
+            ref = `${ref}@${lineOf(c.decl)}`;
+        usedRefs.add(ref);
+        refs.set(c, ref);
+    }
+    const sources = [...input.files.keys()]
+        .filter((f) => /\.(?:[cm]?[jt]sx?)$/.test(f) && !NON_SOURCE.test(f))
+        .sort();
+    const byDecl = new Map();
+    for (const c of list) {
+        byDecl.set(c.decl, c);
+        if (c.impl)
+            byDecl.set(c.impl, c);
+    }
+    const propsByCandidate = new Map();
+    for (const c of list)
+        propsByCandidate.set(c, extractProps(analysis, c));
+    const usage = analyzeUsage({
+        analysis,
+        files: sources,
+        resolveTarget: (tag) => {
+            const decl = jsxTargetDeclaration(checker, tag);
+            return decl ? byDecl.get(decl) : undefined;
+        },
+        enclosing: (node) => {
+            for (let n = node.parent; n; n = n.parent) {
+                const found = byDecl.get(n);
+                if (found)
+                    return found;
+                if (ts.isVariableDeclaration(n) && byDecl.has(n))
+                    return byDecl.get(n);
+            }
+            return undefined;
+        },
+        declared: (c) => {
+            const props = propsByCandidate.get(c);
+            return { names: new Set(props?.props.map((p) => p.name) ?? []), closed: props?.complete === true };
+        }
+    });
+    const components = list.map((c) => {
+        const props = propsByCandidate.get(c);
+        for (const name of props.skipped)
+            note("info", "react.unsupported-prop-name", `Prop "${name}" of ${c.name} cannot be addressed by a fact path and was skipped`, c.decl);
+        if (props.props.length === 0 && !props.complete && props.notes.length > 0)
+            note("warning", "react.props-unresolved", `${c.name}: ${props.notes[0]}`, c.decl);
+        const parent = parents.get(c);
+        const stats = usage.byTarget.get(c);
+        const accessibility = accessibilityOf(c);
+        const styling = stylingOf(analysis, c, { files: input.files, tailwind: input.tailwind });
+        return {
+            ref: refs.get(c),
+            candidate: c,
+            displayName: c.displayName ?? c.name,
+            file: relOf(analysis, c.decl),
+            line: lineOf(c.decl),
+            exports: [...c.exports].sort((a, b) => cmp(a.subpath, b.subpath) || cmp(a.name, b.name)),
+            props,
+            variants: variantsOf(analysis, c, props.props),
+            slots: slotsOf(props.props),
+            ...(accessibility ? { accessibility } : {}),
+            docs: docsOf(analysis, c),
+            ...(styling ? { styling } : {}),
+            ...(stats ? { usage: stats } : {}),
+            renders: [...(usage.renders.get(c) ?? [])]
+                .map(([target, count]) => ({ target: refs.get(target), count }))
+                .sort((a, b) => cmp(a.target, b.target)),
+            ...(parent ? { compoundParent: refs.get(parent) } : {}),
+            subcomponents: c.subcomponents.flatMap((s) => {
+                const child = children.find((x) => x.displayName === `${c.displayName ?? c.name}.${s.key}`);
+                return child ? [{ key: s.key, ref: refs.get(child) }] : [];
+            })
+        };
+    });
+    return { components, diagnostics, analyzedFiles: sources };
+}
+/** `export const Slot = createSlot(…)`: possibly a component made by a factory, which static analysis cannot confirm. */
+function looksLikeFactoryComponent(decl, exportName) {
+    if (!ts.isVariableDeclaration(decl) || !decl.initializer || !ts.isIdentifier(decl.name))
+        return false;
+    const name = exportName === "default" ? decl.name.text : exportName;
+    const init = unwrap(decl.initializer);
+    return /^[A-Z]/.test(name) && !/^[A-Z0-9_]+$/.test(name) && ts.isCallExpression(init);
+}
+function relOf(analysis, node) {
+    return relativeFileOf(analysis, node) ?? node.getSourceFile().fileName;
+}
+function baseName(decl) {
+    const base = posix.basename(decl.getSourceFile().fileName).replace(/\.[^.]+$/, "");
+    return base.charAt(0).toUpperCase() + base.slice(1);
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+//# sourceMappingURL=analyze.js.map

package/dist/compiler-react/behavior.js

@@ -0,0 +1,75 @@
+import { walkSameFunction } from "../compiler-core/index.js";
+import ts from "typescript";
+/**
+ * Slots are derived from props: `children` is the default slot, any other prop whose declared type is
+ * renderable (ReactNode, ReactElement, JSX.Element) is a named slot, and a function prop returning
+ * renderable output is a render-prop slot.
+ */
+export function slotsOf(props) {
+    return props
+        .filter((p) => p.role === "children" || p.role === "slot" || p.role === "render-prop")
+        .map((p) => ({
+        name: p.role === "children" ? "default" : p.name,
+        required: p.required,
+        prop: p.name,
+        typeText: p.typeText,
+        renderProp: p.role === "render-prop"
+    }));
+}
+/** Static `role` and `aria-*` attributes on intrinsic (lowercase) JSX elements in the component body. */
+export function accessibilityOf(candidate) {
+    const impl = candidate.impl;
+    if (!impl)
+        return undefined;
+    const roles = new Set();
+    const attributes = new Set();
+    const visit = (n) => {
+        const element = ts.isJsxSelfClosingElement(n) ? n : ts.isJsxOpeningElement(n) ? n : undefined;
+        if (!element || !/^[a-z]/.test(element.tagName.getText()))
+            return;
+        for (const attribute of element.attributes.properties) {
+            if (!ts.isJsxAttribute(attribute))
+                continue;
+            const name = attribute.name.getText();
+            if (name === "role" && attribute.initializer && ts.isStringLiteral(attribute.initializer))
+                roles.add(attribute.initializer.text);
+            else if (name.startsWith("aria-"))
+                attributes.add(name);
+        }
+    };
+    const walk = (n) => {
+        visit(n);
+        ts.forEachChild(n, walk);
+    };
+    // Nested component definitions inside the body are not this component's markup.
+    if (ts.isFunctionLike(impl) && impl.body)
+        walkSameFunction(impl, visit);
+    else if (ts.isClassLike(impl))
+        walk(impl);
+    if (roles.size === 0 && attributes.size === 0)
+        return undefined;
+    const only = roles.size === 1 ? [...roles][0] : undefined;
+    return { ...(only ? { role: only } : {}), attributes: [...attributes].sort() };
+}
+/** JSDoc on the component declaration: description, `@deprecated`, and `@example` blocks. */
+export function docsOf(analysis, candidate) {
+    const { checker } = analysis;
+    const nameNode = candidate.decl.name;
+    const symbol = nameNode ? checker.getSymbolAtLocation(nameNode) : undefined;
+    if (!symbol)
+        return { examples: [] };
+    const description = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    const tags = symbol.getJsDocTags(checker);
+    const deprecated = tags.find((t) => t.name === "deprecated");
+    const examples = tags
+        .filter((t) => t.name === "example")
+        .map((t) => ts.displayPartsToString(t.text).trim())
+        .filter((t) => t.length > 0);
+    const reason = deprecated ? ts.displayPartsToString(deprecated.text).trim() : undefined;
+    return {
+        ...(description ? { description } : {}),
+        ...(deprecated ? { deprecated: reason ? { reason } : {} } : {}),
+        examples
+    };
+}
+//# sourceMappingURL=behavior.js.map