@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-react/emit.js

@@ -0,0 +1,188 @@
+import { excerpt, lineOf } from "../compiler-core/index.js";
+export const CAPABILITIES = [
+    "name",
+    "description",
+    "lifecycle",
+    "deprecated",
+    "implementations.*",
+    "props.*",
+    "slots.*",
+    "variants.*",
+    "accessibility.*",
+    "examples.*",
+    "styling.*",
+    "usage.*",
+    "composition.*"
+];
+/** Writes one component's facts. Prose from JSDoc is `authored`; everything derived from syntax or types is `extracted`. */
+export function emitComponent(builder, c, pkg) {
+    const ref = builder.entity(c.ref, "component", c.displayName);
+    const at = (node, method = "compiler-api") => {
+        // Project files are loaded under a virtual root, so a node's path is its project-relative path.
+        const file = node.getSourceFile().fileName.replace(/^\//, "");
+        return builder.evidence({
+            sourceRef: `${file}#${c.candidate.name}`,
+            location: { type: "file", path: file, line: lineOf(node) },
+            method,
+            original: excerpt(node)
+        });
+    };
+    const declEv = at(c.candidate.decl);
+    const implEv = at(c.candidate.impl ?? c.candidate.decl);
+    const put = (path, value, evidence, origin = "extracted") => builder.fact(ref, path, value, evidence, { origin });
+    put("name", c.displayName, declEv);
+    if (c.docs.description)
+        put("description", c.docs.description, declEv, "authored");
+    if (c.docs.deprecated) {
+        put("lifecycle", "deprecated", declEv, "authored");
+        put("deprecated", c.docs.deprecated, declEv, "authored");
+    }
+    c.docs.examples.forEach((code, index) => {
+        const id = `example-${index + 1}`;
+        put(`examples.${id}.language`, c.file.split(".").pop() ?? "tsx", declEv, "authored");
+        put(`examples.${id}.code`, code, declEv, "authored");
+    });
+    // Implementation
+    const primary = [...c.exports].sort((a, b) => (a.subpath === "." ? 0 : 1) - (b.subpath === "." ? 0 : 1) ||
+        (a.name === "default" ? 1 : 0) - (b.name === "default" ? 1 : 0) ||
+        (a.name < b.name ? -1 : 1))[0];
+    const impl = "implementations.react";
+    put(`${impl}.framework`, "react", declEv);
+    if (pkg.name)
+        put(`${impl}.packageName`, pkg.name, declEv);
+    if (primary) {
+        put(`${impl}.exportName`, primary.name, declEv);
+        if (pkg.name)
+            put(`${impl}.importPath`, primary.subpath === "." ? pkg.name : `${pkg.name}/${primary.subpath.replace(/^\.\//, "")}`, declEv);
+    }
+    const ext = `${impl}.extensions.react`;
+    put(`${ext}.kind`, c.candidate.kind, declEv);
+    put(`${ext}.file`, c.file, declEv);
+    // Neutral link key: other sources identify a component by (file, local declaration name).
+    put(`${ext}.localName`, c.candidate.name, declEv);
+    put(`${ext}.exports`, c.exports, declEv);
+    put(`${ext}.forwardRef`, c.candidate.wrappers.includes("forwardRef"), declEv);
+    put(`${ext}.memo`, c.candidate.wrappers.includes("memo"), declEv);
+    if (c.candidate.wrappers.length > 0)
+        put(`${ext}.wrappers`, c.candidate.wrappers, declEv);
+    if (c.candidate.refTypeText)
+        put(`${ext}.refType`, c.candidate.refTypeText, declEv);
+    if (c.candidate.reactDisplayName)
+        put(`${ext}.displayName`, c.candidate.reactDisplayName, declEv);
+    if (c.candidate.styled)
+        put(`${ext}.styledLibrary`, c.candidate.styled.library, declEv);
+    if (c.props.generics.length > 0)
+        put(`${ext}.generics`, c.props.generics, declEv);
+    if (c.props.inheritsFrom.length > 0)
+        put(`${ext}.inheritedPropsFrom`, c.props.inheritsFrom, declEv);
+    put(`${ext}.propsComplete`, c.props.complete, declEv);
+    if (c.compoundParent)
+        put(`${ext}.compoundParent`, c.compoundParent, declEv);
+    // Props
+    for (const p of c.props.props) {
+        const base = `props.${p.name}`;
+        const ev = at(p.declaration.node);
+        put(`${base}.type.text`, p.typeText, ev);
+        put(`${base}.type.kind`, p.kind, ev);
+        put(`${base}.required`, p.required, ev);
+        if (p.default !== undefined)
+            put(`${base}.default`, p.default, [ev, implEv]);
+        if (p.defaultExpression !== undefined)
+            put(`${base}.extensions.react.defaultExpression`, p.defaultExpression, implEv);
+        if (p.allowedValues)
+            put(`${base}.allowedValues`, p.allowedValues, ev);
+        if (p.description)
+            put(`${base}.description`, p.description, ev, "authored");
+        if (p.deprecated)
+            put(`${base}.deprecated`, p.deprecated, ev, "authored");
+        put(`${base}.extensions.react.role`, p.role, ev);
+        if (p.inheritedFrom)
+            put(`${base}.extensions.react.inheritedFrom`, p.inheritedFrom, ev);
+    }
+    // Variants
+    for (const v of c.variants) {
+        const ev = v.node ? at(v.node, v.source === "cva" ? "ast" : "compiler-api") : declEv;
+        put(`variants.${v.name}.values`, v.values, ev);
+        if (v.default !== undefined)
+            put(`variants.${v.name}.default`, v.default, ev);
+        put(`variants.${v.name}.extensions.react.source`, v.source, ev);
+        if (v.via)
+            put(`variants.${v.name}.extensions.react.via`, v.via, ev);
+    }
+    // Slots
+    for (const s of c.slots) {
+        put(`slots.${s.name}.declared`, true, declEv);
+        put(`slots.${s.name}.required`, s.required, declEv);
+        put(`slots.${s.name}.extensions.react.prop`, s.prop, declEv);
+        put(`slots.${s.name}.extensions.react.typeText`, s.typeText, declEv);
+        if (s.renderProp)
+            put(`slots.${s.name}.extensions.react.renderProp`, true, declEv);
+    }
+    // Accessibility
+    if (c.accessibility) {
+        if (c.accessibility.role)
+            put("accessibility.role", c.accessibility.role, implEv);
+        if (c.accessibility.attributes.length > 0)
+            put("accessibility.attributes", c.accessibility.attributes, implEv);
+    }
+    // Styling
+    if (c.styling) {
+        const s = c.styling;
+        if (s.cssModules.length > 0)
+            put("styling.cssModules", s.cssModules.map((m) => m.path), implEv);
+        const moduleEvidence = s.cssModules.flatMap((m) => m.variables.map((v) => builder.evidence({
+            sourceRef: `${m.path}#${v.name}`,
+            location: { type: "file", path: m.path, line: v.line },
+            method: "structured-parse",
+            original: `var(${v.name})`
+        })));
+        const variables = [
+            ...new Set([...s.inlineVariables, ...s.cssModules.flatMap((m) => m.variables.map((v) => v.name))])
+        ].sort();
+        if (variables.length > 0)
+            put("styling.cssVariables", variables, [implEv, ...moduleEvidence]);
+        if (s.classNames.length > 0)
+            put("styling.classNames", s.classNames, implEv);
+        if (s.tailwind && s.classNames.length > 0)
+            put("styling.tailwind", true, implEv);
+        if (s.libraries.length > 0)
+            put("styling.libraries", s.libraries, implEv);
+    }
+    // Composition and usage
+    if (c.renders.length > 0)
+        put("composition.renders", c.renders, implEv);
+    if (c.subcomponents.length > 0)
+        put("composition.subcomponents", c.subcomponents, declEv);
+    if (c.usage) {
+        const u = c.usage;
+        const samples = u.samples.map((s) => builder.evidence({
+            sourceRef: `${s.file}#usage`,
+            location: { type: "file", path: s.file, line: s.line },
+            method: "compiler-api",
+            original: s.text
+        }));
+        put("usage.sites", u.sites, samples);
+        // Variant names count as declared (cva variants reach the component through VariantProps).
+        const declared = new Set([...c.props.props.map((p) => p.name), ...c.variants.map((v) => v.name)]);
+        for (const [name, stat] of [...u.props].sort(([a], [b]) => (a < b ? -1 : 1))) {
+            if (!/^[A-Za-z0-9_:-]+$/.test(name))
+                continue;
+            put(`usage.props.${name}.count`, stat.count, samples);
+            if (stat.values.length > 0)
+                put(`usage.props.${name}.observedValues`, stat.values, samples);
+            if (stat.dynamic > 0)
+                put(`usage.props.${name}.dynamicCount`, stat.dynamic, samples);
+            // When the props set is incomplete, absence from it proves nothing, so `declared: false` is not claimed.
+            if (declared.has(name) || c.props.complete)
+                put(`usage.props.${name}.declared`, declared.has(name), samples);
+        }
+        if (u.undeclared.size > 0)
+            put("usage.undeclaredProps", [...u.undeclared].sort(), samples);
+        const combos = [...u.combinations]
+            .map(([key, count]) => ({ props: key === "" ? [] : key.split(","), count }))
+            .sort((a, b) => b.count - a.count || (a.props.join() < b.props.join() ? -1 : 1))
+            .slice(0, 10);
+        put("usage.combinations", combos, samples);
+    }
+}
+//# sourceMappingURL=emit.js.map

package/dist/compiler-react/index.js

@@ -0,0 +1,2 @@
+export { ADAPTER_ID, ADAPTER_VERSION, reactAdapter } from "./adapter.js";
+//# sourceMappingURL=index.js.map

package/dist/compiler-react/program.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import ts from "typescript";
+/**
+ * Builds a type-checking program over the supplied project files only. Nothing is read from
+ * `node_modules` and no customer code runs: third-party types (including `@types/react`) are not
+ * loaded, so references to them stay unresolved and are reported as such rather than guessed.
+ * TypeScript's own `lib.es2022.d.ts` is read so built-in utility types like `Omit` resolve.
+ */
+export function createAnalysis(files) {
+    const virtual = new Map([...files].map(([rel, text]) => [`/${rel}`, text]));
+    const options = {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        jsx: ts.JsxEmit.ReactJSX,
+        lib: ["lib.es2022.d.ts"],
+        types: [],
+        strict: true,
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true,
+        resolveJsonModule: true,
+        allowArbitraryExtensions: true
+    };
+    const libDir = ts.getDefaultLibFilePath(options).replace(/[^/\\]+$/, "");
+    const isLib = (file) => file.startsWith(libDir);
+    const read = (file) => {
+        const text = virtual.get(file);
+        if (text !== undefined)
+            return text;
+        return isLib(file) && existsSync(file) ? readFileSync(file, "utf8") : undefined;
+    };
+    const host = {
+        getSourceFile: (file, languageVersion) => {
+            const text = read(file);
+            return text === undefined ? undefined : ts.createSourceFile(file, text, languageVersion, true);
+        },
+        getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+        writeFile: () => { },
+        getCurrentDirectory: () => "/",
+        getDirectories: () => [],
+        fileExists: (file) => read(file) !== undefined,
+        readFile: read,
+        getCanonicalFileName: (file) => file,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n"
+    };
+    const roots = [...virtual.keys()].filter((f) => /\.(?:[cm]?[jt]sx?)$/.test(f));
+    const program = ts.createProgram({ rootNames: roots, options, host });
+    return {
+        program,
+        checker: program.getTypeChecker(),
+        relativePath: (fileName) => (virtual.has(fileName) ? fileName.slice(1) : undefined),
+        sourceFile: (rel) => program.getSourceFile(`/${rel}`)
+    };
+}
+//# sourceMappingURL=program.js.map

package/dist/compiler-react/props.js

@@ -0,0 +1,157 @@
+import { collapse, describeMember, externalBases, hasModifier, isProjectNode, literalValue, topLevelAssignments, unwrap } from "../compiler-core/index.js";
+import ts from "typescript";
+const RENDERABLE_OR_COMPONENT_TYPE = /^(?:(?:React\.)?(?:ReactNode|ReactElement|ReactChild|ReactFragment|JSX\.Element)(?:<.*>)?|(?:React\.)?ComponentType\b.*)$/;
+const RENDER_FUNCTION = /=>\s*(?:React\.)?(?:ReactNode|ReactElement|JSX\.Element)\b/;
+const PROP_NAME = /^[A-Za-z0-9_:-]+$/;
+export function extractProps(analysis, candidate) {
+    const { checker } = analysis;
+    const notes = [];
+    const typeNode = candidate.propsTypeNode ?? firstParameterType(candidate);
+    const generics = candidate.impl && ts.isFunctionLike(candidate.impl)
+        ? (candidate.impl.typeParameters?.map((p) => p.name.text) ?? [])
+        : [];
+    if (!typeNode) {
+        if (candidate.kind === "lazy")
+            notes.push("lazy component: props are defined by the dynamically imported module");
+        else if (candidate.kind === "styled")
+            notes.push("styled component without a props type argument");
+        else
+            notes.push("no props type could be determined from syntax");
+        return { props: [], inheritsFrom: [], generics, complete: false, skipped: [], notes };
+    }
+    const type = checker.getTypeFromTypeNode(typeNode);
+    const inheritsFrom = [...new Set(externalBases(analysis, typeNode))].sort();
+    const defaults = collectDefaults(candidate);
+    const rootName = declaredTypeName(typeNode);
+    const props = [];
+    const skipped = [];
+    // One member that does not resolve (a type from a package that is not installed) turns the whole intersection into
+    // `any`; reading the members one by one keeps the props of the rest.
+    const parts = ts.isIntersectionTypeNode(typeNode) && (type.flags & ts.TypeFlags.Any) !== 0
+        ? typeNode.types.map((n) => checker.getTypeFromTypeNode(n))
+        : [type];
+    const seen = new Set();
+    for (const part of parts) {
+        if ((part.flags & ts.TypeFlags.Any) !== 0)
+            continue;
+        for (const symbol of checker.getPropertiesOfType(part)) {
+            if (seen.has(symbol.name))
+                continue;
+            seen.add(symbol.name);
+            const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+            if (!declaration || !isProjectNode(analysis, declaration))
+                continue;
+            if (!PROP_NAME.test(symbol.name)) {
+                skipped.push(symbol.name);
+                continue;
+            }
+            props.push(describeProp({ analysis, symbol, declaration, rootName, defaults, candidate }));
+        }
+    }
+    props.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const resolvedAny = (type.flags & ts.TypeFlags.Any) !== 0;
+    if (resolvedAny)
+        notes.push("props type did not resolve");
+    if (candidate.propsUnknown && props.length === 0)
+        notes.push("props type did not resolve");
+    return {
+        props,
+        inheritsFrom,
+        generics,
+        complete: !candidate.openProps &&
+            inheritsFrom.length === 0 &&
+            skipped.length === 0 &&
+            !resolvedAny &&
+            !(candidate.propsUnknown && props.length === 0),
+        skipped,
+        notes
+    };
+}
+function describeProp(input) {
+    const { analysis, symbol, declaration, rootName, defaults } = input;
+    const member = describeMember(analysis, symbol, declaration, { renderable: RENDERABLE_OR_COMPONENT_TYPE });
+    const fallback = defaults.get(symbol.name);
+    return {
+        name: member.name,
+        typeText: member.typeText,
+        kind: member.kind,
+        required: member.required,
+        ...(fallback?.value !== undefined ? { default: fallback.value } : {}),
+        ...(fallback && fallback.value === undefined ? { defaultExpression: fallback.expression } : {}),
+        ...(member.allowedValues ? { allowedValues: member.allowedValues } : {}),
+        ...(member.description ? { description: member.description } : {}),
+        ...(member.deprecated ? { deprecated: member.deprecated } : {}),
+        ...(member.parentName && member.parentName !== rootName ? { inheritedFrom: member.parentName } : {}),
+        role: roleOf(member.name, member.typeText, member.kind),
+        declaration: { node: declaration, line: member.line }
+    };
+}
+function roleOf(name, typeText, kind) {
+    if (name === "children")
+        return "children";
+    if (name === "ref")
+        return "ref";
+    if (kind === "function")
+        return RENDER_FUNCTION.test(typeText) ? "render-prop" : /^on[A-Z]/.test(name) ? "event-handler" : "prop";
+    if (kind === "component")
+        return "slot";
+    return "prop";
+}
+function firstParameterType(candidate) {
+    const impl = candidate.impl;
+    if (!impl)
+        return undefined;
+    if (ts.isClassLike(impl))
+        return undefined;
+    return impl.parameters[0]?.type;
+}
+function declaredTypeName(node) {
+    return ts.isTypeReferenceNode(node) ? node.typeName.getText() : undefined;
+}
+/** Defaults from destructuring initializers, `static defaultProps`, and `Name.defaultProps = {…}`. */
+function collectDefaults(candidate) {
+    const defaults = new Map();
+    const set = (name, init) => {
+        const value = literalValue(init);
+        defaults.set(name, {
+            ...(value !== undefined ? { value } : {}),
+            expression: collapse(init.getText()).slice(0, 200)
+        });
+    };
+    const impl = candidate.impl;
+    if (impl && ts.isFunctionLike(impl)) {
+        const first = impl.parameters[0];
+        if (first && ts.isObjectBindingPattern(first.name)) {
+            for (const element of first.name.elements) {
+                if (!element.initializer || element.dotDotDotToken)
+                    continue;
+                const key = element.propertyName ?? element.name;
+                if (ts.isIdentifier(key) || ts.isStringLiteralLike(key))
+                    set(key.text, element.initializer);
+            }
+        }
+    }
+    const fromObject = (expression) => {
+        const object = unwrap(expression);
+        if (!ts.isObjectLiteralExpression(object))
+            return;
+        for (const p of object.properties) {
+            if (ts.isPropertyAssignment(p) && (ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)))
+                set(p.name.text, p.initializer);
+        }
+    };
+    if (impl && ts.isClassLike(impl)) {
+        for (const member of impl.members) {
+            if (ts.isPropertyDeclaration(member) &&
+                hasModifier(member, ts.SyntaxKind.StaticKeyword) &&
+                member.name.getText() === "defaultProps" &&
+                member.initializer)
+                fromObject(member.initializer);
+        }
+    }
+    const assigned = topLevelAssignments(candidate.decl.getSourceFile()).get(`${candidate.name}.defaultProps`);
+    if (assigned)
+        fromObject(assigned);
+    return defaults;
+}
+//# sourceMappingURL=props.js.map

package/dist/compiler-react/styling.js

@@ -0,0 +1,138 @@
+import { posix, relativeFileOf, unwrap } from "../compiler-core/index.js";
+import ts from "typescript";
+const CSS_MODULE = /\.module\.(?:css|scss|sass|less)$/;
+const VAR_REFERENCE = /var\(\s*(--[\w-]+)/g;
+const CLASS_HELPERS = new Set(["cn", "clsx", "classNames", "classnames", "cx", "twMerge"]);
+const MAX_CLASSES = 200;
+/**
+ * Styling references found in a component: imported CSS modules and the custom properties they use,
+ * `var(--x)` references in the component source, literal `className` tokens, and CSS-in-JS libraries.
+ * References are recorded as written; they are not resolved to tokens here.
+ */
+export function stylingOf(analysis, candidate, context) {
+    const node = candidate.impl ?? candidate.decl;
+    const file = relativeFileOf(analysis, candidate.decl);
+    if (!file)
+        return undefined;
+    const sf = candidate.decl.getSourceFile();
+    const cssModules = [];
+    const libraries = new Set();
+    if (candidate.styled)
+        libraries.add(candidate.styled.library);
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const specifier = statement.moduleSpecifier.text;
+        if (specifier === "@emotion/react" && usesCssProp(node))
+            libraries.add("emotion");
+        if (!CSS_MODULE.test(specifier) || !specifier.startsWith("."))
+            continue;
+        const local = statement.importClause?.name?.text;
+        if (!local || !referencesIdentifier(node, local))
+            continue;
+        const path = posix.normalize(posix.join(posix.dirname(file), specifier));
+        const text = context.files.get(path);
+        cssModules.push({ path, variables: text === undefined ? [] : variableLines(text) });
+    }
+    const source = node.getText(sf);
+    const inlineVariables = [...new Set([...source.matchAll(VAR_REFERENCE)].map((m) => m[1]))].sort();
+    const classNames = classNamesIn(node);
+    if (cssModules.length === 0 &&
+        inlineVariables.length === 0 &&
+        classNames.length === 0 &&
+        libraries.size === 0)
+        return undefined;
+    return {
+        cssModules,
+        inlineVariables,
+        classNames,
+        tailwind: context.tailwind,
+        libraries: [...libraries].sort()
+    };
+}
+function variableLines(css) {
+    const seen = new Map();
+    css.split("\n").forEach((text, index) => {
+        for (const match of text.matchAll(VAR_REFERENCE))
+            if (!seen.has(match[1]))
+                seen.set(match[1], index + 1);
+    });
+    return [...seen]
+        .map(([name, line]) => ({ name, line }))
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+function referencesIdentifier(root, name) {
+    let found = false;
+    const walk = (n) => {
+        if (found)
+            return;
+        if (ts.isIdentifier(n) && n.text === name)
+            found = true;
+        else
+            ts.forEachChild(n, walk);
+    };
+    walk(root);
+    return found;
+}
+function usesCssProp(root) {
+    let found = false;
+    const walk = (n) => {
+        if (found)
+            return;
+        if (ts.isJsxAttribute(n) && n.name.getText() === "css")
+            found = true;
+        else
+            ts.forEachChild(n, walk);
+    };
+    walk(root);
+    return found;
+}
+function classNamesIn(root) {
+    const out = new Set();
+    const add = (text) => {
+        for (const token of text.split(/\s+/))
+            if (token && out.size < MAX_CLASSES)
+                out.add(token);
+    };
+    const fromExpression = (expression) => {
+        const node = unwrap(expression);
+        if (ts.isStringLiteralLike(node))
+            add(node.text);
+        else if (ts.isTemplateExpression(node)) {
+            add(node.head.text);
+            for (const span of node.templateSpans) {
+                add(span.literal.text);
+                fromExpression(span.expression);
+            }
+        }
+        else if (ts.isConditionalExpression(node)) {
+            fromExpression(node.whenTrue);
+            fromExpression(node.whenFalse);
+        }
+        else if (ts.isBinaryExpression(node)) {
+            fromExpression(node.right);
+        }
+        else if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            CLASS_HELPERS.has(node.expression.text)) {
+            for (const argument of node.arguments)
+                fromExpression(argument);
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            for (const element of node.elements)
+                fromExpression(element);
+        }
+    };
+    const walk = (n) => {
+        if (ts.isJsxAttribute(n) && n.name.getText() === "className" && n.initializer) {
+            if (ts.isStringLiteral(n.initializer))
+                add(n.initializer.text);
+            else if (ts.isJsxExpression(n.initializer) && n.initializer.expression)
+                fromExpression(n.initializer.expression);
+        }
+        ts.forEachChild(n, walk);
+    };
+    walk(root);
+    return [...out].sort();
+}
+//# sourceMappingURL=styling.js.map

package/dist/compiler-react/usage.js

@@ -0,0 +1,116 @@
+import { lineOf, literalValue, relativeFileOf } from "../compiler-core/index.js";
+import ts from "typescript";
+const MAX_VALUES = 20;
+const MAX_SAMPLES = 5;
+// Attributes that every element accepts regardless of its declared props.
+const UNIVERSAL = new Set(["key", "ref"]);
+/**
+ * Counts JSX sites that statically resolve to a known component: observed prop names and literal
+ * values, prop combinations, undeclared props, and which components render which. Values passed as
+ * expressions are counted as dynamic, never guessed. Frequencies are static source counts, not runtime.
+ */
+export function analyzeUsage(input) {
+    const { analysis, files, resolveTarget, enclosing, declared } = input;
+    const byTarget = new Map();
+    const renders = new Map();
+    for (const file of files) {
+        const sf = analysis.sourceFile(file);
+        if (!sf)
+            continue;
+        const visit = (node) => {
+            if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node))
+                record(node);
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    return { byTarget, renders };
+    function record(element) {
+        const tag = element.tagName;
+        if (ts.isIdentifier(tag) && /^[a-z]/.test(tag.text))
+            return;
+        const target = resolveTarget(tag);
+        if (!target)
+            return;
+        const stats = byTarget.get(target) ?? {
+            sites: 0,
+            props: new Map(),
+            combinations: new Map(),
+            undeclared: new Set(),
+            samples: []
+        };
+        byTarget.set(target, stats);
+        stats.sites++;
+        const file = relativeFileOf(analysis, element);
+        if (file && stats.samples.length < MAX_SAMPLES)
+            stats.samples.push({
+                file,
+                line: lineOf(element),
+                text: element.getText().split("\n")[0]?.slice(0, 200) ?? ""
+            });
+        const names = [];
+        let spread = false;
+        for (const attribute of element.attributes.properties) {
+            if (ts.isJsxSpreadAttribute(attribute)) {
+                spread = true;
+                continue;
+            }
+            const name = attribute.name.getText();
+            if (name.includes(":") && !name.startsWith("aria-") && !name.startsWith("data-"))
+                continue;
+            names.push(name);
+            const entry = stats.props.get(name) ?? { count: 0, values: [], valuesTruncated: false, dynamic: 0 };
+            entry.count++;
+            const value = attributeValue(attribute);
+            if (value === undefined)
+                entry.dynamic++;
+            else if (!entry.values.some((v) => JSON.stringify(v) === JSON.stringify(value))) {
+                if (entry.values.length < MAX_VALUES)
+                    entry.values.push(value);
+                else
+                    entry.valuesTruncated = true;
+            }
+            stats.props.set(name, entry);
+        }
+        if (ts.isJsxOpeningElement(element) &&
+            ts.isJsxElement(element.parent) &&
+            element.parent.children.some((c) => !(ts.isJsxText(c) && c.containsOnlyTriviaWhiteSpaces))) {
+            names.push("children");
+            const entry = stats.props.get("children") ?? {
+                count: 0,
+                values: [],
+                valuesTruncated: false,
+                dynamic: 0
+            };
+            entry.count++;
+            entry.dynamic++;
+            stats.props.set("children", entry);
+        }
+        const key = [...new Set(names)].sort().join(",");
+        stats.combinations.set(key, (stats.combinations.get(key) ?? 0) + 1);
+        const { names: known, closed } = declared(target);
+        if (closed && !spread)
+            for (const name of names)
+                if (!known.has(name) && !UNIVERSAL.has(name))
+                    stats.undeclared.add(name);
+        const parent = enclosing(element);
+        if (parent) {
+            const children = renders.get(parent) ?? new Map();
+            children.set(target, (children.get(target) ?? 0) + 1);
+            renders.set(parent, children);
+        }
+    }
+}
+function attributeValue(attribute) {
+    const init = attribute.initializer;
+    if (!init)
+        return true;
+    if (ts.isStringLiteral(init))
+        return init.text;
+    if (ts.isJsxExpression(init) && init.expression) {
+        const value = literalValue(init.expression);
+        return value !== undefined && typeof value !== "object" ? value : undefined;
+    }
+    return undefined;
+}
+//# sourceMappingURL=usage.js.map