@trackunit/iris-app 2.5.12 → 2.5.13

package/migrations/p-content-space-codemod/resolve-content-shell.js

@@ -0,0 +1,968 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveContentShell = exports.resolveContentShells = void 0;
+const tslib_1 = require("tslib");
+const css_classname_utils_1 = require("@trackunit/css-classname-utils");
+const types_1 = require("@typescript-eslint/types");
+const typescript_estree_1 = require("@typescript-eslint/typescript-estree");
+const path_1 = tslib_1.__importDefault(require("path"));
+const classname_ast_rewrite_1 = require("../utils/classname-ast-rewrite");
+const shell_skip_reason_1 = require("./shell-skip-reason");
+const DEFAULT_ENTRY_COMPONENT_FILE = "index.tsx";
+const unresolvedShell = (code, detail) => ({
+    status: "unresolved",
+    reason: (0, shell_skip_reason_1.shellSkipReason)(code, detail),
+});
+const unresolvedShells = (code, detail) => ({
+    status: "unresolved",
+    reason: (0, shell_skip_reason_1.shellSkipReason)(code, detail),
+});
+/** Intrinsic hosts treated as content-region shells for this walking skeleton. */
+const DIV_LIKE_ELEMENTS = new Set(["div", "main", "section"]);
+/**
+ * Known non-DOM wrappers to skip when walking from an extension entry toward
+ * the content shell (providers, Suspense, fragments).
+ * `RouterProvider` is intentionally NOT a wrapper — it branches into light-touch
+ * multi-route discovery instead of being skipped.
+ */
+const isKnownWrapperName = (name) => {
+    if (name === "Suspense" ||
+        name === "Fragment" ||
+        name === "TrackunitInternalProviders" ||
+        name === "TrackunitProviders") {
+        return true;
+    }
+    return name.endsWith("Provider") && name !== "RouterProvider";
+};
+/**
+ * Walks from `extension.main` through known non-DOM wrappers and static
+ * imports to identify editable content-region classname host(s).
+ *
+ * Multi-route policy (light-touch, static imports only):
+ * 1. Shared layout shell (div-like host wrapping `<Outlet />`) wins → one target.
+ * 2. Else each resolvable route leaf with a clear shell is targeted.
+ * 3. Exotic / unclear graphs → `{ status: "unresolved" }` (never throws; no first-div guess).
+ */
+const resolveContentShells = (tree, extension) => {
+    const entryPath = `${extension.sourceRoot}/${extension.main ?? DEFAULT_ENTRY_COMPONENT_FILE}`;
+    if (!tree.exists(entryPath)) {
+        return unresolvedShells("entry-missing", entryPath);
+    }
+    return resolveShellsFromFile(tree, entryPath, extension.sourceRoot, new Set());
+};
+exports.resolveContentShells = resolveContentShells;
+/**
+ * Single-shell convenience wrapper over {@link resolveContentShells}.
+ * Returns the first resolved shell when discovery finds one or more; unresolved
+ * when none. Prefer {@link resolveContentShells} for RouterProvider / multi-route
+ * graphs — an arbitrary one of N leaves is not a useful production answer.
+ */
+const resolveContentShell = (tree, extension) => {
+    const result = (0, exports.resolveContentShells)(tree, extension);
+    if (result.status === "unresolved") {
+        return { status: "unresolved", reason: result.reason };
+    }
+    const shell = result.shells[0];
+    if (shell === undefined) {
+        return unresolvedShell("unclear-graph", "resolved status with empty shells list");
+    }
+    return { status: "resolved", shell };
+};
+exports.resolveContentShell = resolveContentShell;
+const resolveShellsFromFile = (tree, filePath, sourceRoot, visited) => {
+    if (visited.has(filePath)) {
+        return unresolvedShells("cycle", filePath);
+    }
+    visited.add(filePath);
+    const content = tree.read(filePath, "utf-8");
+    if (content === null) {
+        return unresolvedShells("entry-missing", filePath);
+    }
+    let program;
+    try {
+        program = (0, classname_ast_rewrite_1.parseTsestreeSource)(content);
+    }
+    catch {
+        return unresolvedShells("parse-failed", filePath);
+    }
+    const rootJsx = findRootJsxElement(program);
+    if (rootJsx === null) {
+        return unresolvedShells("no-root-jsx", filePath);
+    }
+    const leaf = unwrapWrappers(rootJsx);
+    if (leaf === null) {
+        return unresolvedShells("empty-wrapper", filePath);
+    }
+    if (isDivLikeHost(leaf) && leaf.type === types_1.AST_NODE_TYPES.JSXElement) {
+        const single = pickContentShellInFile(filePath, program, leaf);
+        if (single.status === "unresolved") {
+            return { status: "unresolved", reason: single.reason };
+        }
+        return { status: "resolved", shells: [single.shell], skippedRouteNames: [] };
+    }
+    const componentName = getJsxComponentName(leaf);
+    if (componentName === null) {
+        return unresolvedShells("non-host-element", filePath);
+    }
+    if (componentName === "RouterProvider" && leaf.type === types_1.AST_NODE_TYPES.JSXElement) {
+        return resolveFromRouterProvider(tree, filePath, program, leaf, sourceRoot, visited);
+    }
+    if (isDynamicComponent(program, componentName)) {
+        return unresolvedShells("dynamic-component", componentName);
+    }
+    const importPath = resolveStaticLocalImport(tree, program, filePath, sourceRoot, componentName);
+    if (importPath === null) {
+        return unresolvedShells("unresolvable-import", componentName);
+    }
+    return resolveShellsFromFile(tree, importPath, sourceRoot, visited);
+};
+/**
+ * Light-touch RouterProvider follow: read `router={name}`, resolve the router
+ * module (import or same-file), collect Identifier `component:` targets from
+ * `createRootRoute` / `createRoute` / `createRootRouteWithContext`. Skip arrow
+ * wrappers and exotic graphs rather than guessing.
+ */
+const resolveFromRouterProvider = (tree, filePath, program, routerProvider, sourceRoot, visited) => {
+    const routerName = getRouterPropIdentifier(routerProvider);
+    if (routerName === null) {
+        return unresolvedShells("router-prop-unresolved");
+    }
+    const routerModulePath = resolveStaticLocalImport(tree, program, filePath, sourceRoot, routerName);
+    if (routerModulePath !== null) {
+        return collectShellsFromRouterModule(tree, routerModulePath, sourceRoot, visited);
+    }
+    // Same-file router (route factories live alongside RouterProvider).
+    return collectShellsFromRouterProgram(tree, filePath, program, sourceRoot, visited);
+};
+const collectShellsFromRouterModule = (tree, routerModulePath, sourceRoot, visited) => {
+    if (visited.has(routerModulePath)) {
+        return unresolvedShells("cycle", routerModulePath);
+    }
+    visited.add(routerModulePath);
+    const content = tree.read(routerModulePath, "utf-8");
+    if (content === null) {
+        return unresolvedShells("entry-missing", routerModulePath);
+    }
+    let program;
+    try {
+        program = (0, classname_ast_rewrite_1.parseTsestreeSource)(content);
+    }
+    catch {
+        return unresolvedShells("parse-failed", routerModulePath);
+    }
+    return collectShellsFromRouterProgram(tree, routerModulePath, program, sourceRoot, visited);
+};
+const collectShellsFromRouterProgram = (tree, routerFilePath, program, sourceRoot, visited) => {
+    const routes = collectRouterRoutes(program);
+    if (routes.length === 0) {
+        return unresolvedShells("router-no-analysable-leaves", "no createRoute/createRootRoute factories found");
+    }
+    if (routes.every(route => route.componentName === null)) {
+        return unresolvedShells("router-inline-arrow-components", routerFilePath);
+    }
+    const definedVariableNames = new Set(routes.flatMap(route => (route.variableName === null ? [] : [route.variableName])));
+    const skippedRouteNames = collectAddChildrenIdentifiers(program).filter(name => !definedVariableNames.has(name));
+    const analyzed = [];
+    for (const route of routes) {
+        if (route.componentName === null) {
+            analyzed.push({ ...route, analysis: null });
+            continue;
+        }
+        const componentFile = resolveComponentModulePath(tree, program, routerFilePath, sourceRoot, route.componentName);
+        if (componentFile === null) {
+            skippedRouteNames.push(route.componentName);
+            analyzed.push({ ...route, analysis: null });
+            continue;
+        }
+        const analysis = analyzeRouteComponent(tree, componentFile, route.componentName, sourceRoot, new Set(visited));
+        if (analysis === null) {
+            skippedRouteNames.push(route.componentName);
+            analyzed.push({ ...route, analysis: null });
+            continue;
+        }
+        analyzed.push({ ...route, analysis });
+    }
+    const shells = selectShellsForInvent(analyzed);
+    if (shells.length === 0) {
+        const skipped = uniqueNames(skippedRouteNames);
+        return unresolvedShells("router-no-analysable-leaves", skipped.length > 0 ? `skipped: ${skipped.join(", ")}` : routerFilePath);
+    }
+    return {
+        status: "resolved",
+        shells: dedupeShells(shells),
+        skippedRouteNames: uniqueNames(skippedRouteNames),
+    };
+};
+const analyzeRouteComponent = (tree, filePath, componentName, sourceRoot, visited) => {
+    if (visited.has(`${filePath}#${componentName}`)) {
+        return null;
+    }
+    visited.add(`${filePath}#${componentName}`);
+    const content = tree.read(filePath, "utf-8");
+    if (content === null) {
+        return null;
+    }
+    let program;
+    try {
+        program = (0, classname_ast_rewrite_1.parseTsestreeSource)(content);
+    }
+    catch {
+        return null;
+    }
+    const rootJsx = findJsxReturnedByName(program, componentName);
+    if (rootJsx === null) {
+        return null;
+    }
+    const leaf = unwrapWrappers(rootJsx);
+    if (leaf === null) {
+        return null;
+    }
+    if (isDivLikeHost(leaf) && leaf.type === types_1.AST_NODE_TYPES.JSXElement) {
+        const shellResult = pickContentShellInFile(filePath, program, leaf);
+        if (shellResult.status === "unresolved") {
+            return null;
+        }
+        const wrapsOutlet = elementContainsOutlet(leaf) || hostWrapsOutletOneHop(tree, filePath, program, leaf, sourceRoot, visited);
+        return { kind: wrapsOutlet ? "layout-shell" : "leaf-shell", shell: shellResult.shell };
+    }
+    const childName = getJsxComponentName(leaf);
+    if (childName === null || childName === "Outlet") {
+        return null;
+    }
+    if (isDynamicComponent(program, childName)) {
+        return null;
+    }
+    const importPath = resolveStaticLocalImport(tree, program, filePath, sourceRoot, childName);
+    if (importPath === null) {
+        return null;
+    }
+    // Preserve nested kind: a one-hop wrapper around an Outlet layout
+    // (`Root` → `Shell` with Outlet) must stay `layout-shell` so shared layout
+    // wins over clear leaves. Forcing `leaf-shell` here double-invents.
+    return analyzeRouteComponent(tree, importPath, childName, sourceRoot, visited);
+};
+const getRouterPropIdentifier = (element) => {
+    for (const attribute of element.openingElement.attributes) {
+        if (attribute.type !== types_1.AST_NODE_TYPES.JSXAttribute)
+            continue;
+        if (attribute.name.type !== types_1.AST_NODE_TYPES.JSXIdentifier || attribute.name.name !== "router")
+            continue;
+        if (attribute.value?.type !== types_1.AST_NODE_TYPES.JSXExpressionContainer)
+            continue;
+        if (attribute.value.expression.type === types_1.AST_NODE_TYPES.Identifier) {
+            return attribute.value.expression.name;
+        }
+    }
+    return null;
+};
+const getVariableDeclaratorInit = (declarator) => {
+    if (!("init" in declarator)) {
+        return null;
+    }
+    return declarator.init ?? null;
+};
+/**
+ * Collects TanStack route factory bindings (`createRootRoute` / `createRoute` /
+ * `createRootRouteWithContext`) with parent links from `getParentRoute`.
+ * Arrow `component` wrappers have `componentName: null` (not guessed).
+ */
+const collectRouterRoutes = (program) => {
+    const coveredRanges = new Set();
+    const routes = [];
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (node.type !== types_1.AST_NODE_TYPES.VariableDeclarator)
+                return;
+            if (node.id.type !== types_1.AST_NODE_TYPES.Identifier)
+                return;
+            const init = getVariableDeclaratorInit(node);
+            if (init === null || init.type !== types_1.AST_NODE_TYPES.CallExpression)
+                return;
+            if (!isRouteFactoryCall(init))
+                return;
+            const options = init.arguments[0];
+            if (options?.type !== types_1.AST_NODE_TYPES.ObjectExpression)
+                return;
+            coveredRanges.add(`${init.range[0]}:${init.range[1]}`);
+            routes.push({
+                variableName: node.id.name,
+                componentName: getComponentIdentifierFromOptions(options),
+                parentVariableName: getParentRouteIdentifier(options),
+            });
+        },
+    });
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (node.type !== types_1.AST_NODE_TYPES.CallExpression)
+                return;
+            if (!isRouteFactoryCall(node))
+                return;
+            if (coveredRanges.has(`${node.range[0]}:${node.range[1]}`))
+                return;
+            const options = node.arguments[0];
+            if (options?.type !== types_1.AST_NODE_TYPES.ObjectExpression)
+                return;
+            routes.push({
+                variableName: null,
+                componentName: getComponentIdentifierFromOptions(options),
+                parentVariableName: getParentRouteIdentifier(options),
+            });
+        },
+    });
+    return routes;
+};
+const getParentRouteIdentifier = (options) => {
+    for (const property of options.properties) {
+        if (property.type !== types_1.AST_NODE_TYPES.Property)
+            continue;
+        if (property.key.type !== types_1.AST_NODE_TYPES.Identifier || property.key.name !== "getParentRoute")
+            continue;
+        if (property.value.type !== types_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+            property.value.type !== types_1.AST_NODE_TYPES.FunctionExpression) {
+            continue;
+        }
+        if (property.value.body.type === types_1.AST_NODE_TYPES.Identifier) {
+            return property.value.body.name;
+        }
+        if (property.value.body.type === types_1.AST_NODE_TYPES.BlockStatement) {
+            for (const statement of property.value.body.body) {
+                if (statement.type !== types_1.AST_NODE_TYPES.ReturnStatement || statement.argument === null)
+                    continue;
+                const arg = unwrapParentheses(statement.argument);
+                if (arg.type === types_1.AST_NODE_TYPES.Identifier) {
+                    return arg.name;
+                }
+            }
+        }
+    }
+    return null;
+};
+const collectAddChildrenIdentifiers = (program) => {
+    const names = [];
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (node.type !== types_1.AST_NODE_TYPES.CallExpression)
+                return;
+            if (node.callee.type !== types_1.AST_NODE_TYPES.MemberExpression || node.callee.computed)
+                return;
+            if (node.callee.property.type !== types_1.AST_NODE_TYPES.Identifier)
+                return;
+            if (node.callee.property.name !== "addChildren")
+                return;
+            const arg = node.arguments[0];
+            if (arg?.type !== types_1.AST_NODE_TYPES.ArrayExpression)
+                return;
+            for (const element of arg.elements) {
+                if (element?.type === types_1.AST_NODE_TYPES.Identifier) {
+                    names.push(element.name);
+                }
+            }
+        },
+    });
+    return names;
+};
+const CONTENT_SPACE_TOKEN = "p-content-space";
+const shellHasContentSpace = (shell) => (0, css_classname_utils_1.splitClasses)(shell.classnameValue).includes(CONTENT_SPACE_TOKEN);
+/**
+ * Layout-wins is per route subtree: a layout covers only descendant leaves.
+ * Already-migrated descendant leaves must not get a second inset on the layout.
+ */
+const selectShellsForInvent = (routes) => {
+    const byVariable = new Map();
+    for (const route of routes) {
+        if (route.variableName !== null) {
+            byVariable.set(route.variableName, route);
+        }
+    }
+    const layouts = routes.filter(route => route.analysis?.kind === "layout-shell");
+    const leaves = routes.filter(route => route.analysis?.kind === "leaf-shell");
+    const coveredLeaves = new Set();
+    const selected = [];
+    for (const layout of layouts) {
+        if (layout.analysis?.kind !== "layout-shell")
+            continue;
+        const descendants = leaves.filter(leaf => isDescendantOf(leaf, layout, byVariable));
+        const descendantsAlreadyMigrated = descendants.some(leaf => leaf.analysis !== null && shellHasContentSpace(leaf.analysis.shell));
+        if (descendantsAlreadyMigrated) {
+            continue;
+        }
+        selected.push(layout.analysis.shell);
+        for (const descendant of descendants) {
+            coveredLeaves.add(descendant);
+        }
+    }
+    for (const leaf of leaves) {
+        if (coveredLeaves.has(leaf) || leaf.analysis?.kind !== "leaf-shell")
+            continue;
+        selected.push(leaf.analysis.shell);
+    }
+    return selected;
+};
+const isDescendantOf = (leaf, layout, byVariable) => {
+    if (layout.variableName === null)
+        return false;
+    let current = leaf.parentVariableName;
+    const seen = new Set();
+    while (current !== null && !seen.has(current)) {
+        if (current === layout.variableName)
+            return true;
+        seen.add(current);
+        current = byVariable.get(current)?.parentVariableName ?? null;
+    }
+    return false;
+};
+const uniqueNames = (names) => {
+    const seen = new Set();
+    const result = [];
+    for (const name of names) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        result.push(name);
+    }
+    return result;
+};
+const isRouteFactoryCall = (node) => {
+    const directName = getCalleeIdentifierName(node.callee);
+    if (directName === "createRootRoute" || directName === "createRoute") {
+        return true;
+    }
+    // createRootRouteWithContext<T>()({ ... })
+    if (node.callee.type === types_1.AST_NODE_TYPES.CallExpression) {
+        const innerName = getCalleeIdentifierName(node.callee.callee);
+        return innerName === "createRootRouteWithContext";
+    }
+    return false;
+};
+const getCalleeIdentifierName = (callee) => {
+    if (callee.type === types_1.AST_NODE_TYPES.Identifier) {
+        return callee.name;
+    }
+    if (callee.type === types_1.AST_NODE_TYPES.TSInstantiationExpression) {
+        return getCalleeIdentifierName(callee.expression);
+    }
+    return null;
+};
+const getComponentIdentifierFromOptions = (options) => {
+    for (const property of options.properties) {
+        if (property.type !== types_1.AST_NODE_TYPES.Property)
+            continue;
+        if (property.key.type !== types_1.AST_NODE_TYPES.Identifier || property.key.name !== "component")
+            continue;
+        if (property.value.type === types_1.AST_NODE_TYPES.Identifier) {
+            return property.value.name;
+        }
+    }
+    return null;
+};
+const resolveComponentModulePath = (tree, program, fromFilePath, sourceRoot, componentName) => {
+    const imported = resolveStaticLocalImport(tree, program, fromFilePath, sourceRoot, componentName);
+    if (imported !== null) {
+        return imported;
+    }
+    if (findJsxReturnedByName(program, componentName) !== null) {
+        return fromFilePath;
+    }
+    return null;
+};
+const elementContainsOutlet = (element) => {
+    let found = false;
+    (0, typescript_estree_1.simpleTraverse)(element, {
+        enter: node => {
+            if (found)
+                return;
+            if (node.type !== types_1.AST_NODE_TYPES.JSXOpeningElement)
+                return;
+            const name = getJsxOpeningName(node.name);
+            if (name === "Outlet") {
+                found = true;
+            }
+        },
+    });
+    return found;
+};
+/**
+ * True when a div-like shell's `<Outlet />` lives one custom-component hop
+ * below (`<div><Main /></div>` where `Main` returns `<Outlet />`). Without this,
+ * the ancestor is padded as a leaf alongside real route leaves.
+ */
+const hostWrapsOutletOneHop = (tree, filePath, program, host, sourceRoot, visited) => {
+    for (const childName of collectCustomChildComponentNames(host)) {
+        if (childName === "Outlet") {
+            return true;
+        }
+        if (componentReturnsOutletOneHop(tree, filePath, program, childName, sourceRoot, visited)) {
+            return true;
+        }
+    }
+    return false;
+};
+const collectCustomChildComponentNames = (host) => {
+    const names = [];
+    for (const child of host.children) {
+        if (child.type !== types_1.AST_NODE_TYPES.JSXElement)
+            continue;
+        const name = getJsxComponentName(child);
+        if (name !== null) {
+            names.push(name);
+        }
+    }
+    return names;
+};
+const componentReturnsOutletOneHop = (tree, fromFilePath, fromProgram, componentName, sourceRoot, visited) => {
+    const visitKey = `${fromFilePath}#outlet-hop#${componentName}`;
+    if (visited.has(visitKey)) {
+        return false;
+    }
+    visited.add(visitKey);
+    let program = fromProgram;
+    if (findJsxReturnedByName(fromProgram, componentName) === null) {
+        const importPath = resolveStaticLocalImport(tree, fromProgram, fromFilePath, sourceRoot, componentName);
+        if (importPath === null) {
+            return false;
+        }
+        const content = tree.read(importPath, "utf-8");
+        if (content === null) {
+            return false;
+        }
+        try {
+            program = (0, classname_ast_rewrite_1.parseTsestreeSource)(content);
+        }
+        catch {
+            return false;
+        }
+    }
+    const jsx = findJsxReturnedByName(program, componentName);
+    if (jsx === null) {
+        return false;
+    }
+    if (getJsxComponentName(jsx) === "Outlet") {
+        return true;
+    }
+    return elementContainsOutlet(jsx);
+};
+const dedupeShells = (shells) => {
+    const seen = new Set();
+    const result = [];
+    for (const shell of shells) {
+        const key = `${shell.filePath}:${shell.location.reportNode.range[0]}:${shell.location.reportNode.range[1]}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(shell);
+    }
+    return result;
+};
+/**
+ * Finds the JSX element returned by the entry's primary component:
+ * `singleSpaReact({ rootComponent })` when present, otherwise the first
+ * exported function/const whose body returns JSX.
+ */
+const findRootJsxElement = (program) => {
+    const singleSpaRootName = findSingleSpaRootComponentName(program);
+    if (singleSpaRootName !== null) {
+        return findJsxReturnedByName(program, singleSpaRootName);
+    }
+    for (const statement of program.body) {
+        const name = getExportedComponentName(statement);
+        if (name === null)
+            continue;
+        const jsx = findJsxReturnedByName(program, name);
+        if (jsx !== null)
+            return jsx;
+    }
+    return null;
+};
+const findSingleSpaRootComponentName = (program) => {
+    let result = null;
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (result !== null)
+                return;
+            if (node.type !== types_1.AST_NODE_TYPES.CallExpression)
+                return;
+            if (!isCalleeNamed(node.callee, "singleSpaReact"))
+                return;
+            if (node.arguments[0]?.type !== types_1.AST_NODE_TYPES.ObjectExpression)
+                return;
+            for (const property of node.arguments[0].properties) {
+                if (property.type !== types_1.AST_NODE_TYPES.Property)
+                    continue;
+                if (property.key.type !== types_1.AST_NODE_TYPES.Identifier || property.key.name !== "rootComponent")
+                    continue;
+                if (property.value.type === types_1.AST_NODE_TYPES.Identifier) {
+                    result = property.value.name;
+                }
+            }
+        },
+    });
+    return result;
+};
+const getExportedComponentName = (statement) => {
+    if (statement.type === types_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+        if (statement.declaration?.type === types_1.AST_NODE_TYPES.FunctionDeclaration) {
+            return statement.declaration.id?.name ?? null;
+        }
+        if (statement.declaration?.type === types_1.AST_NODE_TYPES.VariableDeclaration) {
+            const declarator = statement.declaration.declarations[0];
+            if (declarator.id.type === types_1.AST_NODE_TYPES.Identifier) {
+                return declarator.id.name;
+            }
+        }
+    }
+    if (statement.type === types_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
+        if (statement.declaration.type === types_1.AST_NODE_TYPES.Identifier) {
+            return statement.declaration.name;
+        }
+        if (statement.declaration.type === types_1.AST_NODE_TYPES.FunctionDeclaration) {
+            return statement.declaration.id?.name ?? null;
+        }
+    }
+    return null;
+};
+const findJsxReturnedByName = (program, name) => {
+    for (const statement of program.body) {
+        const fn = matchNamedFunctionLike(statement, name);
+        if (fn !== null) {
+            return findReturnedJsx(fn);
+        }
+    }
+    return null;
+};
+const matchNamedFunctionLike = (statement, name) => {
+    const decl = statement.type === types_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+        statement.type === types_1.AST_NODE_TYPES.ExportDefaultDeclaration
+        ? statement.declaration
+        : statement;
+    if (decl === null)
+        return null;
+    if (decl.type === types_1.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null && decl.id.name === name) {
+        return decl.body;
+    }
+    if (decl.type === types_1.AST_NODE_TYPES.VariableDeclaration) {
+        for (const declarator of decl.declarations) {
+            if (declarator.id.type !== types_1.AST_NODE_TYPES.Identifier || declarator.id.name !== name)
+                continue;
+            const init = declarator.init;
+            if (init === null)
+                return null;
+            if (init.type === types_1.AST_NODE_TYPES.ArrowFunctionExpression || init.type === types_1.AST_NODE_TYPES.FunctionExpression) {
+                return init.body;
+            }
+        }
+    }
+    if (statement.type === types_1.AST_NODE_TYPES.FunctionDeclaration && statement.id.name === name) {
+        return statement.body;
+    }
+    return null;
+};
+const findReturnedJsx = (body) => {
+    if (body.type === types_1.AST_NODE_TYPES.JSXElement || body.type === types_1.AST_NODE_TYPES.JSXFragment) {
+        return body;
+    }
+    if (body.type === types_1.AST_NODE_TYPES.BlockStatement) {
+        for (const statement of body.body) {
+            if (statement.type !== types_1.AST_NODE_TYPES.ReturnStatement || statement.argument === null)
+                continue;
+            const arg = unwrapParentheses(statement.argument);
+            if (arg.type === types_1.AST_NODE_TYPES.JSXElement || arg.type === types_1.AST_NODE_TYPES.JSXFragment) {
+                return arg;
+            }
+        }
+    }
+    return null;
+};
+const unwrapParentheses = (expression) => {
+    let current = expression;
+    while (current.type === types_1.AST_NODE_TYPES.TSAsExpression || current.type === types_1.AST_NODE_TYPES.TSSatisfiesExpression) {
+        current = current.expression;
+    }
+    return current;
+};
+/**
+ * Skips known provider / Suspense / fragment wrappers down to the first
+ * meaningful child (host element or custom component).
+ */
+const unwrapWrappers = (node) => {
+    let current = node;
+    for (;;) {
+        if (current.type === types_1.AST_NODE_TYPES.JSXFragment) {
+            const child = firstJsxChild(current.children);
+            if (child === null)
+                return null;
+            current = child;
+            continue;
+        }
+        const name = getJsxComponentName(current);
+        if (name !== null && isKnownWrapperName(name)) {
+            const child = firstJsxChild(current.children);
+            if (child === null)
+                return null;
+            current = child;
+            continue;
+        }
+        return current;
+    }
+};
+const firstJsxChild = (children) => {
+    for (const child of children) {
+        if (child.type === types_1.AST_NODE_TYPES.JSXElement || child.type === types_1.AST_NODE_TYPES.JSXFragment) {
+            return child;
+        }
+    }
+    return null;
+};
+const isDivLikeHost = (element) => {
+    if (element.type !== types_1.AST_NODE_TYPES.JSXElement)
+        return false;
+    const name = getJsxOpeningName(element.openingElement.name);
+    return name !== null && DIV_LIKE_ELEMENTS.has(name);
+};
+const getJsxComponentName = (element) => {
+    if (element.type !== types_1.AST_NODE_TYPES.JSXElement)
+        return null;
+    const name = getJsxOpeningName(element.openingElement.name);
+    if (name === null)
+        return null;
+    if (DIV_LIKE_ELEMENTS.has(name))
+        return null;
+    if (/^[a-z]/.test(name))
+        return null;
+    return name;
+};
+const getJsxOpeningName = (name) => {
+    if (name.type === types_1.AST_NODE_TYPES.JSXIdentifier)
+        return name.name;
+    return null;
+};
+/**
+ * Confidence rule for this phase: a single editable content-region classname
+ * host that itself owns scrollable overflow (`overflow-auto` / `scroll` /
+ * `overlay`, including axis-prefixed forms). Clipping overflow (`hidden` /
+ * `clip`), a scrolling descendant, or a header-ish child (`PageHeader` /
+ * `Topbar` / `Header`) make the host unresolved — those cases go to the
+ * unresolved-surface report for a human to place the inset.
+ *
+ * Classnames must be bound to the host's `className`/`class` attribute (literal
+ * on the attribute, direct Tailwind call in the attribute, or the local
+ * binding of that attribute's identifier/callee). Never invent from unrelated
+ * file-wide classname locations.
+ */
+const pickContentShellInFile = (filePath, program, host) => {
+    const hostClassnames = collectEditableClassnamesForHost(program, host);
+    if (hostClassnames.length === 0) {
+        return unresolvedShell("no-editable-classname", filePath);
+    }
+    if (hostClassnames.some(classname => classListHasClippingOverflow((0, css_classname_utils_1.splitClasses)(classname.value)))) {
+        return unresolvedShell("clipping-overflow-on-host", filePath);
+    }
+    const candidates = hostClassnames.filter(isContentShellClassname);
+    if (candidates.length === 0) {
+        return unresolvedShell("no-overflow-on-host", filePath);
+    }
+    if (candidates.length > 1) {
+        return unresolvedShell("multiple-overflow-candidates", filePath);
+    }
+    if (hostRendersHeader(host)) {
+        return unresolvedShell("header-on-shell", filePath);
+    }
+    if (descendantOwnsScroll(program, host)) {
+        return unresolvedShell("descendant-owns-scroll", filePath);
+    }
+    const location = candidates[0];
+    if (location === undefined) {
+        return unresolvedShell("unclear-graph", filePath);
+    }
+    return {
+        status: "resolved",
+        shell: {
+            filePath,
+            classnameValue: location.value,
+            combinedClassnameValue: hostClassnames.map(hostLocation => hostLocation.value).join(" "),
+            location,
+        },
+    };
+};
+const collectEditableClassnamesForHost = (program, host) => {
+    const attribute = host.openingElement.attributes.find((attr) => attr.type === types_1.AST_NODE_TYPES.JSXAttribute &&
+        attr.name.type === types_1.AST_NODE_TYPES.JSXIdentifier &&
+        (attr.name.name === "className" || attr.name.name === "class"));
+    if (attribute === undefined)
+        return [];
+    // Direct literal classnames on the attribute.
+    const fromAttribute = (0, classname_ast_rewrite_1.findClassnameLocations)(program).filter(location => {
+        if (location.context.type !== "jsx-attribute")
+            return false;
+        return location.reportNode.range[0] >= attribute.range[0] && location.reportNode.range[1] <= attribute.range[1];
+    });
+    if (fromAttribute.length > 0)
+        return fromAttribute;
+    const value = attribute.value;
+    if (value?.type !== types_1.AST_NODE_TYPES.JSXExpressionContainer)
+        return [];
+    const expression = value.expression;
+    if (expression.type === types_1.AST_NODE_TYPES.CallExpression) {
+        return collectClassnamesBoundToCallExpression(program, expression);
+    }
+    if (expression.type === types_1.AST_NODE_TYPES.Identifier) {
+        return collectClassnamesBoundToIdentifier(program, expression.name);
+    }
+    return [];
+};
+/**
+ * `className={cva("...")}` — locations inside this call only.
+ * `className={layout()}` — locations inside the local binding of `layout` only.
+ */
+const collectClassnamesBoundToCallExpression = (program, callExpression) => {
+    if (callExpression.callee.type !== types_1.AST_NODE_TYPES.Identifier) {
+        return [];
+    }
+    const calleeName = callExpression.callee.name;
+    if ((0, css_classname_utils_1.isTailwindFunction)(calleeName)) {
+        return (0, classname_ast_rewrite_1.findClassnameLocations)(program).filter(location => location.reportNode.range[0] >= callExpression.range[0] &&
+            location.reportNode.range[1] <= callExpression.range[1]);
+    }
+    return collectClassnamesBoundToIdentifier(program, calleeName);
+};
+const collectClassnamesBoundToIdentifier = (program, name) => {
+    const bindingRange = findLocalBindingInitializerRange(program, name);
+    if (bindingRange === null) {
+        return [];
+    }
+    return (0, classname_ast_rewrite_1.findClassnameLocations)(program).filter(location => location.reportNode.range[0] >= bindingRange[0] && location.reportNode.range[1] <= bindingRange[1]);
+};
+const findLocalBindingInitializerRange = (program, name) => {
+    let result = null;
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (result !== null)
+                return;
+            if (node.type !== types_1.AST_NODE_TYPES.VariableDeclarator)
+                return;
+            if (node.id.type !== types_1.AST_NODE_TYPES.Identifier || node.id.name !== name)
+                return;
+            if (node.init === null)
+                return;
+            result = node.init.range;
+        },
+    });
+    return result;
+};
+const SCROLLABLE_OVERFLOW = /(^|:)overflow-(x-|y-)?(auto|scroll|overlay)$/;
+const CLIPPING_OVERFLOW = /(^|:)overflow-(x-|y-)?(hidden|clip)$/;
+const classListHasScrollableOverflow = (classes) => classes.some(cls => SCROLLABLE_OVERFLOW.test(cls));
+const classListHasClippingOverflow = (classes) => classes.some(cls => CLIPPING_OVERFLOW.test(cls));
+const isContentShellClassname = (location) => {
+    const classes = (0, css_classname_utils_1.splitClasses)(location.value);
+    if (classListHasClippingOverflow(classes))
+        return false;
+    return classListHasScrollableOverflow(classes);
+};
+const HEADER_ISH_NAMES = new Set(["PageHeader", "Topbar", "Header"]);
+const hostRendersHeader = (host) => jsxElementsUnder(host).some(element => {
+    const name = getJsxOpeningName(element.openingElement.name);
+    return name !== null && HEADER_ISH_NAMES.has(name);
+});
+const descendantOwnsScroll = (program, host) => jsxElementsUnder(host).some(element => collectEditableClassnamesForHost(program, element).some(isContentShellClassname));
+const jsxElementsUnder = (host) => {
+    const found = [];
+    const visit = (children) => {
+        for (const child of children) {
+            if (child.type === types_1.AST_NODE_TYPES.JSXElement) {
+                found.push(child);
+                visit(child.children);
+            }
+            else if (child.type === types_1.AST_NODE_TYPES.JSXFragment) {
+                visit(child.children);
+            }
+        }
+    };
+    visit(host.children);
+    return found;
+};
+const isDynamicComponent = (program, componentName) => {
+    let isDynamic = false;
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (isDynamic)
+                return;
+            if (node.type !== types_1.AST_NODE_TYPES.VariableDeclarator)
+                return;
+            if (node.id.type !== types_1.AST_NODE_TYPES.Identifier || node.id.name !== componentName)
+                return;
+            if (node.init === null)
+                return;
+            if (containsDynamicImport(node.init)) {
+                isDynamic = true;
+            }
+        },
+    });
+    return isDynamic;
+};
+const containsDynamicImport = (node) => {
+    let found = false;
+    (0, typescript_estree_1.simpleTraverse)(node, {
+        enter: child => {
+            if (found)
+                return;
+            if (child.type === types_1.AST_NODE_TYPES.ImportExpression) {
+                found = true;
+            }
+        },
+    });
+    return found;
+};
+/**
+ * Resolves a component name to a static relative/local import under
+ * `sourceRoot`. Returns null for external packages or missing bindings.
+ */
+const resolveStaticLocalImport = (tree, program, fromFilePath, sourceRoot, componentName) => {
+    for (const statement of program.body) {
+        if (statement.type !== types_1.AST_NODE_TYPES.ImportDeclaration)
+            continue;
+        const specifier = statement.source.value;
+        if (typeof specifier !== "string")
+            continue;
+        const bindsComponent = statement.specifiers.some(spec => {
+            if (spec.type === types_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                return spec.local.name === componentName;
+            }
+            if (spec.type === types_1.AST_NODE_TYPES.ImportSpecifier) {
+                return spec.local.name === componentName;
+            }
+            return false;
+        });
+        if (!bindsComponent)
+            continue;
+        if (!(specifier.startsWith("./") || specifier.startsWith("../"))) {
+            return null;
+        }
+        const fromDir = path_1.default.posix.dirname(fromFilePath);
+        const resolvedWithoutExt = path_1.default.posix.normalize(path_1.default.posix.join(fromDir, specifier));
+        const candidates = [
+            resolvedWithoutExt,
+            `${resolvedWithoutExt}.tsx`,
+            `${resolvedWithoutExt}.ts`,
+            `${resolvedWithoutExt}/index.tsx`,
+            `${resolvedWithoutExt}/index.ts`,
+        ];
+        for (const candidate of candidates) {
+            if (candidate === fromFilePath)
+                continue;
+            if (!candidate.startsWith(`${sourceRoot}/`) && candidate !== sourceRoot)
+                continue;
+            if (!(candidate.endsWith(".tsx") || candidate.endsWith(".ts")))
+                continue;
+            if (tree.exists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    // Local const binding (e.g. LazyPage) without an import — not followable as a
+    // static local module.
+    return null;
+};
+const isCalleeNamed = (callee, name) => {
+    return callee.type === types_1.AST_NODE_TYPES.Identifier && callee.name === name;
+};
+//# sourceMappingURL=resolve-content-shell.js.map