@component-compass/parser-react 0.0.4 → 0.1.0

package/dist/walk-jsx.js

@@ -1,1041 +0,0 @@
-import { relative, isAbsolute } from "node:path";
-import { walk } from "oxc-walker";
-import { serialiseComponentId, externalPackageOf } from "@component-compass/plugin-core";
-import { asTagName, asWrapperId } from "@component-compass/plugin-core";
-import { posixPath, classifyImportOrigin, positionAt } from "@component-compass/ast-utils";
-// React-API factories whose return value is conventionally a component.
-// Detected by callee identifier name OR `React.<name>` member-expression.
-// Detection is callee-name only — we don't try to verify the factory's
-// return shape.
-const LOCAL_COMPONENT_FACTORIES = new Set(["forwardRef", "memo", "lazy"]);
-// HOC names recognised for owner-binding unwrap (mirrors find-owner.ts).
-const HOC_NAMES = new Set(["memo", "forwardRef", "observer"]);
-/**
- * Walk a JSXMemberExpression chain to its root identifier, returning the
- * flat dotted name (e.g. "Tabs.Trigger.Inner") and the root identifier name.
- * Returns null if the chain bottoms out at anything other than a JSXIdentifier.
- */
-function readMemberChain(node) {
-    const parts = [];
-    let current = node;
-    while (current.type === "JSXMemberExpression") {
-        parts.unshift(current.property.name);
-        current = current.object;
-    }
-    if (current.type !== "JSXIdentifier")
-        return null;
-    parts.unshift(current.name);
-    return { compoundName: parts.join("."), rootName: current.name };
-}
-/**
- * Build an opportunistic Occurrence for an unmapped import — used when
- * `resolveOpening` returns undefined but the root identifier matches an
- * unmappedImports entry. `tail` is the compound-name suffix after the root
- * (null for bare `<Foo/>`, "Bar" for `<Foo.Bar/>`, "Bar.Baz" for deeper).
- *
- * `unmapped.modulePath` is the package-relative resolved module path when the
- * lazy resolver landed on a leaf (paired with non-null `leafPackage`); null
- * otherwise (unresolvable specifier or bare-package fallback through
- * classifyImportOrigin). The emission threads it onto the external identity
- * so downstream consumers can disambiguate same-export entries served from
- * different package subpaths (#63).
- *
- * Two terminal paths:
- *   - `unmapped.leafPackage` set → opaque external occurrence rooted at the
- *     leaf package; compound usages prefix the tail with the importedName
- *     (with the `default.` prefix stripped for default-import roots).
- *   - else → classifyImportOrigin → local-source match against the
- *     local-index by-path map.
- */
-function emitOpportunistic(unmapped, tail, opening, opts, source) {
-    const compoundExport = tail === null
-        ? unmapped.importedName
-        : unmapped.importedName === "default"
-            ? tail
-            : `${unmapped.importedName}.${tail}`;
-    const via = { kind: "direct-import", specifier: unmapped.specifier, import: unmapped.importedName };
-    const loc = locOf(opening, opts.file, source);
-    if (unmapped.leafPackage) {
-        const { props, events } = readJsxAttrs(opening, opts.captureValues);
-        return {
-            componentId: {
-                kind: "react-component",
-                export: compoundExport,
-                source: {
-                    type: "external",
-                    package: unmapped.leafPackage,
-                    ...(unmapped.modulePath !== null ? { modulePath: unmapped.modulePath } : {}),
-                },
-            },
-            loc,
-            via,
-            props,
-            events,
-        };
-    }
-    // Fallback: classifyImportOrigin to determine whether the specifier is
-    // external or local. The lazy resolver returns null only for genuinely
-    // unresolvable specifiers or workspace siblings now (identity resolution
-    // always runs for external imports). Distinguish the two cases here:
-    //   - external → emit an opaque occurrence keyed by package name; manifest
-    //     stays null (manifest enrichment and identity resolution are separate)
-    //   - local    → match against the local index (original path below)
-    //   - unresolved → nothing to emit
-    const origin = classifyImportOrigin(unmapped.specifier, {
-        repoRoot: opts.repoRoot,
-        fromFile: opts.file,
-    });
-    if (origin.type === "external") {
-        const { props, events } = readJsxAttrs(opening, opts.captureValues);
-        return {
-            componentId: {
-                kind: "react-component",
-                export: compoundExport,
-                source: {
-                    type: "external",
-                    package: origin.package,
-                    ...(unmapped.modulePath !== null ? { modulePath: unmapped.modulePath } : {}),
-                },
-            },
-            loc,
-            via,
-            props,
-            events,
-        };
-    }
-    // Bare-specifier fallback: classifyImportOrigin returns "unresolved" for
-    // workspace-symlinked packages (no node_modules/ segment in the resolved
-    // path, yet outside the fixture root). If the specifier looks like a bare
-    // npm package name, use it directly as the package name — identity is
-    // preserved; manifest stays null.
-    if (origin.type === "unresolved" && isBarePackageSpecifier(unmapped.specifier)) {
-        const pkgName = unmapped.specifier.startsWith("@")
-            ? unmapped.specifier.split("/").slice(0, 2).join("/")
-            : (unmapped.specifier.split("/")[0] ?? unmapped.specifier);
-        const { props, events } = readJsxAttrs(opening, opts.captureValues);
-        return {
-            componentId: {
-                kind: "react-component",
-                export: compoundExport,
-                source: {
-                    type: "external",
-                    package: pkgName,
-                    ...(unmapped.modulePath !== null ? { modulePath: unmapped.modulePath } : {}),
-                },
-            },
-            loc,
-            via,
-            props,
-            events,
-        };
-    }
-    if (origin.type !== "local")
-        return undefined;
-    const localDefs = opts.localIndex.byPath.get(origin.filePath);
-    const matched = localDefs?.find((d) => unmapped.importedName === "default"
-        ? d.isDefault
-        : d.exportName === unmapped.importedName && !d.isDefault);
-    if (!matched || matched.componentId.kind !== "react-component")
-        return undefined;
-    if (tail !== null && matched.componentId.source.type !== "local")
-        return undefined;
-    const { props, events } = readJsxAttrs(opening, opts.captureValues);
-    // For bare usage (tail null): identity is the local def's componentId.
-    // For compound: rebuild with `matched.exportName.tail` (stripping
-    // `default.` for default-exported locals — mirrors the leafPackage path).
-    if (tail === null) {
-        return { componentId: matched.componentId, loc, via, props, events };
-    }
-    const localCompoundExport = matched.exportName === "default" ? tail : `${matched.exportName}.${tail}`;
-    return {
-        componentId: {
-            kind: "react-component",
-            export: localCompoundExport,
-            source: matched.componentId.source,
-        },
-        loc,
-        via,
-        props,
-        events,
-    };
-}
-// Pre-parsed oxc Program is supplied by scan.ts (single source of truth for
-// parsing). Tasks 1-7 of Phase C swapped parsing to oxc-parser; this walker
-// drives off the resulting Program node. Recovered parse errors land on the
-// raw ParseResult.errors field upstream — oxc-parser carries them on the
-// result, not the Program, so they are warned at parse time and not
-// re-emitted here.
-export function walkJsx(opts) {
-    const program = opts.ast;
-    const source = opts.source;
-    const occurrences = [];
-    const wrappers = [];
-    const imports = [];
-    const warnings = [];
-    const localBindings = new Map();
-    // Tracks imports that did NOT match a manifest entry: local → { importedName,
-    // specifier, leafPackage, modulePath }. `leafPackage` is non-null when the
-    // lazy resolver landed on a leaf package but had no manifest entry for
-    // `importedName` — in that case the third pass attributes the opaque external
-    // occurrence to the leaf rather than re-running origin classification on the
-    // user-written aggregator specifier. `modulePath` is the package-relative
-    // resolved path (paired with `leafPackage`); null when the resolver returned
-    // no hit, threaded onto the external identity by the JSX-emission pass.
-    const unmappedImports = new Map();
-    // ── Pass 1: collect imports + local Context / factory bindings ──────────
-    // Single pre-pass over the program populates `localBindings` and
-    // `unmappedImports` so the wrapper-detection (pass 2) and JSX-emission
-    // (pass 3) passes have a complete view of what's bound.
-    walk(program, {
-        enter(node) {
-            if (node.type === "VariableDeclarator") {
-                collectLocalVarBinding(node, localBindings);
-                return;
-            }
-            if (node.type === "ImportDeclaration") {
-                collectImportBindings(node, opts, localBindings, unmappedImports, imports, source);
-            }
-        },
-    });
-    const wrapperStack = [];
-    const ancestorMap = new WeakMap();
-    const parentOf = (n) => ancestorMap.get(n) ?? null;
-    walk(program, {
-        enter(node, parent) {
-            if (parent)
-                ancestorMap.set(node, parent);
-            const candidate = wrapperCandidate(node, parent ?? null, program, parentOf);
-            if (candidate)
-                wrapperStack.push(candidate);
-            if (node.type === "JSXOpeningElement") {
-                const frame = wrapperStack[wrapperStack.length - 1];
-                if (frame)
-                    collectWrapperDep(node, localBindings, opts.lookupByTag, frame);
-            }
-        },
-        leave(node) {
-            const top = wrapperStack[wrapperStack.length - 1];
-            if (top && top.node === node) {
-                wrapperStack.pop();
-                if (top.deps.length > 0) {
-                    wrappers.push({
-                        id: wrapperId(top.name),
-                        name: top.name,
-                        file: posixPath(opts.file),
-                        exportName: top.exportName,
-                        componentDeps: top.deps,
-                    });
-                }
-            }
-        },
-    });
-    /** Topmost element is the current tracked parent. node is kept for matched
-     *  pop on exit (depth-first traversal guarantees the topmost stack entry is
-     *  the current node when its exit handler fires). */
-    const parentStack = [];
-    const renderPropStack = [];
-    const ownerStack = [];
-    function resolveOpening(opening) {
-        const nameNode = opening.name;
-        const start = opening.start;
-        const loc = typeof start === "number" ? positionAt(source, start) : { line: 1, column: 0 };
-        if (nameNode.type === "JSXMemberExpression") {
-            const chain = readMemberChain(nameNode);
-            if (!chain) {
-                opts.collector?.emit({
-                    code: "jsx-shape-unsupported",
-                    severity: "warning",
-                    filePath: opts.file,
-                    line: loc.line,
-                    column: loc.column,
-                    nameType: "JSXMemberExpression-malformed",
-                    detail: "member chain did not bottom out at JSXIdentifier",
-                });
-                return undefined;
-            }
-            if (/^[a-z]/.test(chain.rootName)) {
-                opts.collector?.emit({
-                    code: "jsx-shape-unsupported",
-                    severity: "warning",
-                    filePath: opts.file,
-                    line: loc.line,
-                    column: loc.column,
-                    nameType: "JSXMemberExpression-lowercase-root",
-                    detail: `lowercase root identifier "${chain.rootName}" cannot be a React component`,
-                });
-                return undefined;
-            }
-            const bound = localBindings.get(chain.rootName);
-            if (bound) {
-                // Compound subcomponents always emit as react-component, regardless of
-                // whether the root binding is react-direct or wc-wrapper. The WC-wrapper
-                // folding rule applies only to bare root usage (<Tabs />), never to
-                // compound subcomponents (<Tabs.Trigger />).
-                if (bound.kind === "local-context") {
-                    // `<MyContext.Provider>` / `<MyContext.Consumer>` is access to a
-                    // member of a React Context object, not a separate component
-                    // definition. Skip emission so the artifact doesn't gain a spurious
-                    // `MyContext.Provider` component identity without a real binding site.
-                    return undefined;
-                }
-                if (bound.kind === "local-component") {
-                    // Compound usage of a local var-bound component (e.g. forwardRef'd
-                    // root with static subcomponents attached: `<Button.Header />`).
-                    // Full compound name preserves the access pattern so subcomponents
-                    // surface as distinct identities under the same local-source root.
-                    return { kind: "local-component", export: chain.compoundName };
-                }
-                if (bound.kind === "react-namespace") {
-                    // `import * as Foo from "pkg"` — strip the namespace alias and emit
-                    // the tail as the package's actual export. `via.import` (set in the
-                    // emission step) preserves the local namespace alias so consumers
-                    // can still distinguish namespace-style access from named imports.
-                    // Namespace imports don't trigger per-export resolver hits, so
-                    // modulePath is unknown at this access point.
-                    const tail = chain.compoundName.slice(chain.rootName.length + 1);
-                    return {
-                        kind: "react-direct",
-                        package: bound.package,
-                        export: tail,
-                        specifier: bound.specifier,
-                        importName: bound.importName,
-                        modulePath: null,
-                    };
-                }
-                return {
-                    kind: "react-direct",
-                    package: bound.package,
-                    export: chain.compoundName,
-                    specifier: bound.specifier,
-                    importName: bound.importName,
-                    modulePath: bound.modulePath,
-                };
-            }
-            // Root unbound. If the root matches an unmapped import, skip the
-            // diagnostic — the JSX-element opportunistic block will attempt to emit
-            // an opaque external (or local-source) occurrence using the unmapped
-            // binding. Symmetric with the single-identifier branch which is silent
-            // on unmapped misses.
-            if (!unmappedImports.has(chain.rootName)) {
-                opts.collector?.emit({
-                    code: "jsx-shape-unsupported",
-                    severity: "warning",
-                    filePath: opts.file,
-                    line: loc.line,
-                    column: loc.column,
-                    nameType: "JSXMemberExpression-unbound-root",
-                    detail: `compound JSX with unbound root "${chain.rootName}"`,
-                });
-            }
-            return undefined;
-        }
-        if (nameNode.type !== "JSXIdentifier") {
-            opts.collector?.emit({
-                code: "jsx-shape-unsupported",
-                severity: "warning",
-                filePath: opts.file,
-                line: loc.line,
-                column: loc.column,
-                nameType: nameNode.type,
-                detail: `unhandled JSX element name type: ${nameNode.type}`,
-            });
-            return undefined;
-        }
-        const id = nameNode.name;
-        if (/^[a-z]/.test(id) && id.includes("-")) {
-            const indexed = opts.lookupByTag(asTagName(id));
-            if (indexed) {
-                return { kind: "wc-tag", tagName: asTagName(id), package: externalPackageOf(indexed.source) };
-            }
-            return undefined;
-        }
-        const bound = localBindings.get(id);
-        if (bound?.kind === "wc-wrapper") {
-            return {
-                kind: "wc-wrapper",
-                tagName: bound.tagName,
-                package: bound.package,
-                specifier: bound.specifier,
-                importName: bound.importName,
-            };
-        }
-        if (bound?.kind === "react-direct") {
-            return {
-                kind: "react-direct",
-                package: bound.package,
-                export: bound.export,
-                specifier: bound.specifier,
-                importName: bound.importName,
-                modulePath: bound.modulePath,
-            };
-        }
-        if (bound?.kind === "local-component") {
-            return { kind: "local-component", export: id };
-        }
-        return undefined;
-    }
-    // Render-prop guard: true iff the topmost render-prop frame was pushed
-    // AFTER its lexical parent JSX was entered. The parent JSX adds 1 to
-    // parentStack.length on enter; if the render-prop frame was pushed when
-    // parentStack.length was >= the current value, no JSX was emitted since
-    // — meaning the render-prop scope opened inside the parent's subtree.
-    // (When called, `parentNode` is the topmost parentStack entry.)
-    const isInRenderPropScopeOxc = (parentNode) => {
-        if (!parentNode)
-            return false;
-        const top = renderPropStack[renderPropStack.length - 1];
-        return top !== undefined && top.depthAtPush >= parentStack.length;
-    };
-    walk(program, {
-        enter(node, parent) {
-            // ── Owner-attribution frame push ──────────────────────────────────
-            if (isOwnerCandidateNode(node)) {
-                const grand = parent ? parentOf(parent) : null;
-                ownerStack.push({ node, parent: parent ?? null, grand });
-            }
-            // ── Render-prop scope push ─────────────────────────────────────────
-            // Function bodies and JSXAttribute values open a render-prop boundary.
-            // Tracked at enter so parent-stack maintenance can read them at JSX time.
-            if (node.type === "ArrowFunctionExpression" ||
-                node.type === "FunctionExpression" ||
-                node.type === "FunctionDeclaration" ||
-                node.type === "JSXAttribute") {
-                renderPropStack.push({ node, depthAtPush: parentStack.length });
-            }
-            if (node.type !== "JSXElement")
-                return;
-            const jsxNode = node;
-            const opening = jsxNode.openingElement;
-            const resolved = resolveOpening(opening);
-            let occurrence;
-            if (!resolved) {
-                // Opportunistic emission for unmapped imports (preserves Phase 1
-                // behaviour). Determine the unmapped root + compound tail (if any),
-                // then delegate to emitOpportunistic — single-id and compound paths
-                // share leafPackage → opaque-external and classifyImportOrigin →
-                // local-source resolution.
-                const nameNode = opening.name;
-                let rootId = null;
-                let tail = null;
-                if (nameNode.type === "JSXIdentifier") {
-                    const id = nameNode.name;
-                    if (!/^[a-z]/.test(id) || !id.includes("-"))
-                        rootId = id;
-                }
-                else if (nameNode.type === "JSXMemberExpression") {
-                    const chain = readMemberChain(nameNode);
-                    if (chain && !/^[a-z]/.test(chain.rootName)) {
-                        rootId = chain.rootName;
-                        tail = chain.compoundName.slice(chain.rootName.length + 1);
-                    }
-                }
-                if (rootId !== null) {
-                    const unmapped = unmappedImports.get(rootId);
-                    if (unmapped) {
-                        occurrence = emitOpportunistic(unmapped, tail, opening, opts, source);
-                    }
-                }
-            }
-            else {
-                const { props, events } = readJsxAttrs(opening, opts.captureValues);
-                const loc = locOf(opening, opts.file, source);
-                if (resolved.kind === "wc-tag") {
-                    occurrence = {
-                        componentId: { kind: "custom-element", tagName: resolved.tagName, source: { type: "external", package: resolved.package } },
-                        loc,
-                        via: { kind: "html-tag" },
-                        props,
-                        events,
-                    };
-                }
-                else if (resolved.kind === "wc-wrapper") {
-                    occurrence = {
-                        componentId: { kind: "custom-element", tagName: resolved.tagName, source: { type: "external", package: resolved.package } },
-                        loc,
-                        via: { kind: "react-wrapper", specifier: resolved.specifier, import: resolved.importName },
-                        props,
-                        events,
-                    };
-                }
-                else if (resolved.kind === "local-context") {
-                    occurrence = {
-                        componentId: {
-                            kind: "react-component",
-                            export: resolved.export,
-                            source: { type: "local", filePath: posixPath(opts.file) },
-                        },
-                        loc,
-                        via: { kind: "context-provider" },
-                        props,
-                        events,
-                    };
-                }
-                else if (resolved.kind === "local-component") {
-                    occurrence = {
-                        componentId: {
-                            kind: "react-component",
-                            export: resolved.export,
-                            source: { type: "local", filePath: posixPath(opts.file) },
-                        },
-                        loc,
-                        via: { kind: "local-component" },
-                        props,
-                        events,
-                    };
-                }
-                else {
-                    occurrence = {
-                        componentId: {
-                            kind: "react-component",
-                            export: resolved.export,
-                            source: {
-                                type: "external",
-                                package: resolved.package,
-                                ...(resolved.modulePath !== null ? { modulePath: resolved.modulePath } : {}),
-                            },
-                        },
-                        loc,
-                        via: { kind: "direct-import", specifier: resolved.specifier, import: resolved.importName },
-                        props,
-                        events,
-                    };
-                }
-            }
-            if (!occurrence)
-                return;
-            const parentEntry = parentStack[parentStack.length - 1];
-            if (parentEntry && !isInRenderPropScopeOxc(parentEntry.node)) {
-                occurrence.parentRef = parentEntry.idx;
-                occurrence.depth = parentStack.length;
-            }
-            else {
-                // Render-prop scope OR no parent: treated as fresh root in this lexical scope.
-                occurrence.depth = 0;
-            }
-            const owner = resolveOwnerFromStack(ownerStack, opts.localIndex, opts.file, opts.repoRoot);
-            if (owner !== undefined) {
-                occurrence.ownerComponentId = owner;
-            }
-            const idx = occurrences.length;
-            occurrences.push(occurrence);
-            parentStack.push({ idx, node: jsxNode });
-        },
-        leave(node) {
-            // Pop owner frame first (it's a subset of structural frames).
-            const topOwner = ownerStack[ownerStack.length - 1];
-            if (topOwner && topOwner.node === node)
-                ownerStack.pop();
-            // Pop render-prop frame for function/attribute boundaries we entered.
-            if (node.type === "ArrowFunctionExpression" ||
-                node.type === "FunctionExpression" ||
-                node.type === "FunctionDeclaration" ||
-                node.type === "JSXAttribute") {
-                const topRp = renderPropStack[renderPropStack.length - 1];
-                if (topRp && topRp.node === node)
-                    renderPropStack.pop();
-            }
-            if (node.type !== "JSXElement")
-                return;
-            const top = parentStack[parentStack.length - 1];
-            if (top && top.node === node)
-                parentStack.pop();
-        },
-    });
-    return { occurrences, wrappers, imports, warnings };
-}
-// ── Helpers ──────────────────────────────────────────────────────────────
-function isOwnerCandidateNode(node) {
-    return (node.type === "FunctionDeclaration" ||
-        node.type === "FunctionExpression" ||
-        node.type === "ArrowFunctionExpression" ||
-        node.type === "ClassDeclaration" ||
-        node.type === "ClassExpression");
-}
-/**
- * Resolve the nearest enclosing component-binding from the owner frame
- * stack. Walks innermost-to-outermost; first match wins. Filters via the
- * local-index so non-exported component-shaped functions don't receive
- * owner attribution (matches the babel walker's predicate behaviour, where
- * `resolveOwnerComponentId` consults the local index's by-path entries).
- */
-function resolveOwnerFromStack(ownerStack, localIndex, filePath, repoRoot) {
-    // localIndex.byPath uses repo-root-relative POSIX keys; filePath is absolute.
-    const relPath = isAbsolute(filePath) ? posixPath(relative(repoRoot, filePath)) : filePath;
-    const defs = localIndex.byPath.get(relPath) ?? [];
-    const knownExportNames = new Set(defs.map((d) => d.exportName));
-    const isKnown = (name) => knownExportNames.has(name);
-    for (let i = ownerStack.length - 1; i >= 0; i--) {
-        const frame = ownerStack[i];
-        if (!frame)
-            continue;
-        const binding = bindingForOwnerFrame(frame.node, frame.parent, frame.grand, isKnown);
-        if (binding) {
-            return {
-                kind: "react-component",
-                export: binding.name,
-                source: { type: "local", filePath: posixPath(filePath) },
-            };
-        }
-    }
-    return undefined;
-}
-function bindingForOwnerFrame(node, parent, grand, isKnown) {
-    // class Name { … }
-    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
-        const cls = node;
-        const id = cls.id;
-        if (id && isPascalCase(id.name)) {
-            if (isKnown(id.name)) {
-                return { name: id.name, isDefault: false };
-            }
-        }
-        if (parent?.type === "ExportDefaultDeclaration") {
-            if (isKnown("default")) {
-                return { name: "default", isDefault: true };
-            }
-        }
-        return null;
-    }
-    // function Name() { … }
-    if (node.type === "FunctionDeclaration") {
-        const fn = node;
-        const id = fn.id;
-        if (parent?.type === "ExportDefaultDeclaration") {
-            const name = id && isPascalCase(id.name) ? id.name : "default";
-            if (isKnown(name)) {
-                return { name, isDefault: true };
-            }
-        }
-        if (id && isPascalCase(id.name)) {
-            if (isKnown(id.name)) {
-                return { name: id.name, isDefault: false };
-            }
-        }
-        return null;
-    }
-    // (...) => …  /  function () { … }  (anonymous), examined by its context.
-    if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
-        return bindingFromAnonymousFunctionParent(parent, grand, isKnown);
-    }
-    return null;
-}
-function bindingFromAnonymousFunctionParent(parent, grand, isKnown) {
-    if (!parent)
-        return null;
-    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
-        return bindingFromVariableId(parent.id.name, isKnown);
-    }
-    if (parent.type === "CallExpression" && isHocCallOxc(parent)) {
-        if (!grand)
-            return null;
-        if (grand.type === "VariableDeclarator" && grand.id.type === "Identifier") {
-            return bindingFromVariableId(grand.id.name, isKnown);
-        }
-        if (grand.type === "ExportDefaultDeclaration") {
-            if (isKnown("default")) {
-                return { name: "default", isDefault: true };
-            }
-        }
-        return null;
-    }
-    if (parent.type === "ExportDefaultDeclaration") {
-        if (isKnown("default")) {
-            return { name: "default", isDefault: true };
-        }
-    }
-    return null;
-}
-function bindingFromVariableId(name, isKnown) {
-    if (!isPascalCase(name))
-        return null;
-    if (!isKnown(name))
-        return null;
-    return { name, isDefault: false };
-}
-function isHocCallOxc(call) {
-    if (call.type !== "CallExpression")
-        return false;
-    const callee = call.callee;
-    if (callee.type === "Identifier")
-        return HOC_NAMES.has(callee.name);
-    if (callee.type === "MemberExpression" &&
-        callee.object.type === "Identifier" &&
-        callee.object.name === "React" &&
-        callee.property.type === "Identifier") {
-        return HOC_NAMES.has(callee.property.name);
-    }
-    return false;
-}
-function isPascalCase(name) {
-    return /^[A-Z]/.test(name);
-}
-function collectLocalVarBinding(node, localBindings) {
-    // Detect var bindings whose initializer is a known React-API call:
-    //   - `const X = createContext(...)` / `React.createContext(...)`
-    //   - `const X = forwardRef(...)` / `memo(...)` / `lazy(...)` (and React.* variants)
-    // Scope-agnostic — any binding to a recognised callee gets tracked. The
-    // identity downstream uses `source: { type: "local", filePath }`, so two
-    // identically-named bindings in different files do not collide.
-    if (!node.init || node.init.type !== "CallExpression")
-        return;
-    if (node.id.type !== "Identifier")
-        return;
-    const call = node.init;
-    const callee = call.callee;
-    const localName = node.id.name;
-    const isCreateContext = (callee.type === "Identifier" && callee.name === "createContext") ||
-        (callee.type === "MemberExpression" &&
-            !callee.computed &&
-            callee.property.type === "Identifier" &&
-            callee.property.name === "createContext");
-    if (isCreateContext) {
-        localBindings.set(localName, { kind: "local-context", localName });
-        return;
-    }
-    const factoryName = callee.type === "Identifier"
-        ? callee.name
-        : callee.type === "MemberExpression" &&
-            !callee.computed &&
-            callee.property.type === "Identifier"
-            ? callee.property.name
-            : null;
-    if (factoryName && LOCAL_COMPONENT_FACTORIES.has(factoryName)) {
-        localBindings.set(localName, { kind: "local-component", localName });
-    }
-}
-function collectImportBindings(decl, opts, localBindings, unmappedImports, imports, source) {
-    const specifier = decl.source.value;
-    if (decl.specifiers.length === 0) {
-        // Side-effect import: `import "pkg"`. Prime the resolver's leaf cache
-        // so later HTML / Lit-template tag references find the leaf's CEM
-        // even though no JS-side identifier was ever bound. The empty
-        // exportName won't match anything in matchInLeaf, but the call still
-        // walks into the leaf and populates byTag for tag-only consumers.
-        opts.resolveLazyManifest(opts.file, specifier, "");
-        return;
-    }
-    for (const spec of decl.specifiers) {
-        if (spec.type === "ImportNamespaceSpecifier") {
-            // Namespace imports skip the lazy resolver — there's no specific
-            // exportName to resolve until a compound JSX usage picks one out.
-            // Record the binding so the compound branch in `resolveOpening` can
-            // emit the tail as the export name. `package` is the user-written
-            // specifier; aggregator-following for namespace imports would
-            // require a separate resolver pass and is deferred.
-            const nsSpec = spec;
-            const local = nsSpec.local.name;
-            localBindings.set(local, {
-                kind: "react-namespace",
-                package: specifier,
-                specifier,
-                importName: local,
-            });
-            imports.push({ file: posixPath(opts.file), imported: local, source: specifier, loc: locOf(spec, opts.file, source) });
-            continue;
-        }
-        if (spec.type !== "ImportSpecifier" && spec.type !== "ImportDefaultSpecifier")
-            continue;
-        const importSpec = spec;
-        const imported = spec.type === "ImportSpecifier" ? importedName(spec.imported) : "default";
-        const local = importSpec.local.name;
-        const hit = opts.resolveLazyManifest(opts.file, specifier, imported);
-        if (hit?.matched?.kind === "custom-element") {
-            localBindings.set(local, {
-                kind: "wc-wrapper",
-                tagName: asTagName(hit.matched.tagName),
-                package: hit.leafPackage,
-                specifier,
-                importName: imported,
-                modulePath: hit.modulePath,
-            });
-        }
-        else if (hit?.matched?.kind === "react-component") {
-            localBindings.set(local, {
-                kind: "react-direct",
-                package: hit.leafPackage,
-                export: hit.matched.export,
-                specifier,
-                importName: imported,
-                modulePath: hit.modulePath,
-            });
-        }
-        else if (hit) {
-            // Resolver landed on a leaf but no manifest match → opaque external bound to leaf.
-            unmappedImports.set(local, {
-                importedName: imported,
-                specifier,
-                leafPackage: hit.leafPackage,
-                modulePath: hit.modulePath,
-            });
-        }
-        else {
-            // Specifier did not resolve (could be local relative or unresolvable).
-            unmappedImports.set(local, {
-                importedName: imported,
-                specifier,
-                leafPackage: null,
-                modulePath: null,
-            });
-        }
-        imports.push({ file: posixPath(opts.file), imported: local, source: specifier, loc: locOf(spec, opts.file, source) });
-    }
-}
-function wrapperCandidate(node, parent, program, parentOf) {
-    // Function / class declarations with a PascalCase id, or an
-    // arrow/function-expr assigned to a PascalCase var. Anonymous bindings
-    // outside those patterns aren't tracked — they can't have an exportable
-    // wrapper name.
-    let name = null;
-    if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
-        const id = node.id;
-        if (id && isPascalCase(id.name))
-            name = id.name;
-    }
-    else if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") &&
-        parent?.type === "VariableDeclarator" &&
-        parent.id.type === "Identifier" &&
-        isPascalCase(parent.id.name)) {
-        name = parent.id.name;
-    }
-    if (name === null)
-        return null;
-    return {
-        node,
-        name,
-        exportName: detectExportName(parent, program, parentOf, name),
-        deps: [],
-        seen: new Set(),
-    };
-}
-function detectExportName(parent, program, parentOf, declName) {
-    // Direct containment: walk up via the pre-built ancestor map. oxc does
-    // not auto-populate node.parent, so we thread parentOf through here.
-    for (let p = parent; p; p = parentOf(p)) {
-        if (p.type === "ExportDefaultDeclaration")
-            return "default";
-        if (p.type === "ExportNamedDeclaration")
-            return declName;
-    }
-    // Indirect: a separate `export default Foo;` or `export { Foo as Bar };`
-    // references this declaration by name. Scan the top-level program body.
-    for (const stmt of program.body) {
-        if (stmt.type === "ExportDefaultDeclaration" &&
-            stmt.declaration.type === "Identifier" &&
-            stmt.declaration.name === declName) {
-            return "default";
-        }
-        if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
-            for (const spec of stmt.specifiers) {
-                if (spec.type !== "ExportSpecifier")
-                    continue;
-                if (spec.local.type !== "Identifier" || spec.local.name !== declName)
-                    continue;
-                if (spec.exported.type === "Identifier" && spec.exported.name === "default") {
-                    return "default";
-                }
-                if (spec.exported.type === "Identifier")
-                    return spec.exported.name;
-                return declName;
-            }
-        }
-    }
-    return declName;
-}
-function collectWrapperDep(opening, localBindings, lookupByTag, frame) {
-    const n = opening.name;
-    function addDep(cid) {
-        const key = serialiseComponentId(cid);
-        if (!frame.seen.has(key)) {
-            frame.seen.add(key);
-            frame.deps.push(cid);
-        }
-    }
-    if (n.type === "JSXMemberExpression") {
-        const chain = readMemberChain(n);
-        if (!chain)
-            return;
-        if (/^[a-z]/.test(chain.rootName))
-            return;
-        const bound = localBindings.get(chain.rootName);
-        if (!bound)
-            return;
-        // Locally-declared bindings (Context, var-bound components) are not
-        // external component deps the wrapper "wraps". Skip.
-        if (bound.kind === "local-context" || bound.kind === "local-component")
-            return;
-        // Namespace imports: tail is the package's actual export — strip the
-        // local namespace alias so the wrapper dep records the same export
-        // identity downstream consumers see for non-namespace access patterns.
-        // Namespace bindings have no per-export resolver hit, so modulePath stays
-        // unset on the wrapper-dep identity.
-        const exportName = bound.kind === "react-namespace"
-            ? chain.compoundName.slice(chain.rootName.length + 1)
-            : chain.compoundName;
-        const modulePath = bound.kind === "react-namespace" ? null : bound.modulePath;
-        addDep({
-            kind: "react-component",
-            export: exportName,
-            source: {
-                type: "external",
-                package: bound.package,
-                ...(modulePath !== null ? { modulePath } : {}),
-            },
-        });
-        return;
-    }
-    if (n.type !== "JSXIdentifier")
-        return;
-    const id = n.name;
-    if (/^[a-z]/.test(id) && id.includes("-")) {
-        const indexed = lookupByTag(asTagName(id));
-        if (indexed) {
-            addDep({
-                kind: "custom-element",
-                tagName: asTagName(id),
-                source: { type: "external", package: externalPackageOf(indexed.source) },
-            });
-        }
-        return;
-    }
-    const bound = localBindings.get(id);
-    // Only WC-wrapper bindings count as wrapper component-deps; React-direct
-    // bindings refer to other React components, which are not WC-wrappers.
-    if (bound && bound.kind === "wc-wrapper") {
-        addDep({
-            kind: "custom-element",
-            tagName: bound.tagName,
-            source: { type: "external", package: bound.package },
-        });
-    }
-}
-function wrapperId(name) {
-    const kebab = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-    return asWrapperId(`wrap-${kebab}`);
-}
-// ── Position / attribute helpers ────────────────────────────────────────
-function locOf(node, file, source) {
-    const start = node.start;
-    if (typeof start !== "number") {
-        return { file: posixPath(file), line: 1, column: 1 };
-    }
-    const pos = positionAt(source, start);
-    return {
-        file: posixPath(file),
-        line: pos.line,
-        // babel emits 1-indexed columns at the call sites that read `loc.column`,
-        // matching the visible offset. positionAt returns 0-indexed columns; +1
-        // aligns with the historical babel output the artifact expects.
-        column: pos.column + 1,
-    };
-}
-function importedName(node) {
-    if (node.type === "Identifier")
-        return node.name ?? "";
-    // StringLiteral path for `import { "weird name" as X }`.
-    return node.value ?? "";
-}
-function readJsxAttrs(node, captureValues) {
-    const props = [];
-    const events = [];
-    for (const attr of node.attributes) {
-        // Spread attributes (`{...rest}`) are recorded as a single sentinel prop
-        // so consumers can distinguish "we don't know what props were passed" from
-        // "no props passed". Spec §3.4 — three-state prop tracking.
-        if (attr.type === "JSXSpreadAttribute") {
-            if (props.some((p) => p.name === "...rest"))
-                continue;
-            props.push({ name: "...rest", isDynamic: true, dynamicKind: "spread" });
-            continue;
-        }
-        if (attr.type !== "JSXAttribute")
-            continue;
-        const jsxAttr = attr;
-        const nameNode = jsxAttr.name;
-        const name = nameNode.type === "JSXIdentifier" ? nameNode.name : "";
-        if (!name)
-            continue;
-        // React event handlers are conventionally `on<Event>` props on the JSX side.
-        if (name.startsWith("on") && name.length > 2 && /[A-Z]/.test(name.charAt(2))) {
-            events.push(name.slice(2).toLowerCase());
-            continue;
-        }
-        if (!jsxAttr.value) {
-            // Boolean shorthand `<Foo bar />` → literal `true`.
-            const usage = { name, isDynamic: false };
-            if (captureValues)
-                usage.literalValue = true;
-            props.push(usage);
-            continue;
-        }
-        // oxc emits `Literal` for string/number/boolean (ESTree shape); babel
-        // emitted distinct `StringLiteral` etc. Discriminate by `value` typeof.
-        if (jsxAttr.value.type === "Literal" && typeof jsxAttr.value.value === "string") {
-            const usage = { name, isDynamic: false };
-            if (captureValues)
-                usage.literalValue = jsxAttr.value.value;
-            props.push(usage);
-            continue;
-        }
-        if (jsxAttr.value.type === "JSXExpressionContainer") {
-            // JSXExpressionContainer.expression is JSXExpression = JSXEmptyExpression | Expression
-            // — widen to Node for the unwrap step so the JSXEmptyExpression branch
-            // below is reachable (oxc's Expression union excludes JSXEmptyExpression).
-            const expr = unwrapParens(jsxAttr.value.expression);
-            // Empty expression containers (`{}`) are ignored.
-            if (expr.type === "JSXEmptyExpression")
-                continue;
-            if (expr.type === "Literal") {
-                const litVal = expr.value;
-                const kind = typeof litVal;
-                if (kind === "string" || kind === "number" || kind === "boolean") {
-                    const usage = { name, isDynamic: false };
-                    if (captureValues)
-                        usage.literalValue = litVal;
-                    props.push(usage);
-                    continue;
-                }
-                // null / bigint / regex literals: treat as dynamic-expr.
-                props.push({ name, isDynamic: true, dynamicKind: "expr" });
-                continue;
-            }
-            if (expr.type === "Identifier") {
-                props.push({ name, isDynamic: true, dynamicKind: "identifier" });
-                continue;
-            }
-            props.push({ name, isDynamic: true, dynamicKind: "expr" });
-        }
-    }
-    return { props, events };
-}
-/**
- * Returns true for specifiers that look like bare npm package names — neither
- * relative paths (`.`, `..`) nor absolute paths (`/`). Scoped packages
- * (`@scope/name`) are accepted only when the scope part is non-empty, to
- * exclude alias conventions like `@/foo` where `@` is not an npm scope.
- */
-function isBarePackageSpecifier(specifier) {
-    if (specifier.startsWith(".") || specifier.startsWith("/"))
-        return false;
-    if (specifier.startsWith("@")) {
-        // Scoped package: require a non-empty scope name before the first "/".
-        const slashIdx = specifier.indexOf("/");
-        // No "/" at all (bare "@foo") or scope part is empty ("@/foo") → not a
-        // valid npm scoped package specifier.
-        return slashIdx > 1; // slashIdx 1 means "@/" — scope is empty
-    }
-    return true;
-}
-/**
- * oxc preserves `ParenthesizedExpression` as a real AST node where babel
- * transparently strips them. Anywhere we inspect an expression's shape
- * (JSX-attribute values, return arguments, etc.) we must recurse through
- * these wrappers first.
- */
-function unwrapParens(node) {
-    let cur = node;
-    while (cur.type === "ParenthesizedExpression") {
-        cur = cur.expression;
-    }
-    return cur;
-}
-//# sourceMappingURL=walk-jsx.js.map