@contentful/experience-design-system-extraction 2.34.5-dev-build-ec126bf0.0 → 2.34.5-dev-build-4a4b9e84.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-extraction",
-  "version": "2.34.5-dev-build-ec126bf0.0",
+  "version": "2.34.5-dev-build-4a4b9e84.0",
   "description": "Component extraction engine for the Contentful Experience Design System SDK",
   "license": "MIT",
   "type": "module",

package/dist/src/extract/{astro.d.ts → adapters/astro/extractor.d.ts}

@@ -1,4 +1,4 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
 export declare function extractAstroComponents(filePaths: string[], onProgress?: (p: {
     filesProcessed: number;
     componentsFound: number;

package/dist/src/extract/{astro.js → adapters/astro/extractor.js}

@@ -1,9 +1,10 @@
 import os from 'node:os';
 import { basename } from 'node:path';
 import { Project, Node } from 'ts-morph';
-import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
-import { resolveTypeProperty } from './resolve-type-property.js';
-import { getSourceLineMetadata } from './source-line-metadata.js';
+import { runFileExtractionWorkers } from '../support/file-processing/file-workers.js';
+import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
+import { resolveTypeProperty } from '../support/resolution/type-property.js';
+import { getSourceLineMetadata } from '../support/resolution/source-location.js';
 function extractAllowedValues(typeText) {
     // Check if the type is a union of string literals like 'a' | 'b' | 'c'
     const parts = typeText.split('|').map((p) => p.trim());

package/dist/src/extract/{react.d.ts → adapters/react/extractor.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../model/component.js';
 export declare function extractReactComponents(filePaths: string[]): Promise<ComponentExtractionResult>;

package/dist/src/extract/{react.js → adapters/react/extractor.js}

@@ -1,9 +1,11 @@
 import { Node, SyntaxKind, } from 'ts-morph';
-import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getJsxTagNameNode, extractTsxComponents, getRenderableExports, isIntrinsicJsxElement, } from './tsx-shared.js';
-import { shouldBeSlot } from './slot-detection.js';
-import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc } from './slot-allowed-components.js';
-import { getSourceLineMetadata } from './source-line-metadata.js';
-import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from './structural-slot-evidence.js';
+import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getJsxTagNameNode, extractTsxComponents, getRenderableExports, } from '../support/tsx-shared.js';
+import { shouldBeSlot } from '../../evidence/slot-evidence.js';
+import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from '../../evidence/allowed-components.js';
+import { getSourceLineMetadata } from '../support/resolution/source-location.js';
+import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from '../../evidence/structural-slot-evidence.js';
+import { collectPropDataflow, getComponentIdentity } from './prop-dataflow.js';
+import { resolveBestFunctionNode } from './function-resolution.js';
 const REACT_ELEMENT_GENERIC_TEST = /(?:React\.)?ReactElement\s*<\s*[A-Za-z_$][\w$.]*/;
 function isReactElementGenericSlotType(typeText) {
     return REACT_ELEMENT_GENERIC_TEST.test(typeText);
@@ -817,223 +819,6 @@ function filterImplementationOnlyAliasProps(props, func) {
         return !isImplementationOnlyAliasProp(func, prop.name);
     });
 }
-function getDeclarationIdentity(node) {
-    if (Node.isIdentifier(node)) {
-        const parent = node.getParent();
-        if ((Node.isVariableDeclaration(parent) || Node.isBindingElement(parent) || Node.isParameterDeclaration(parent)) &&
-            parent.getNameNode() === node) {
-            return parent;
-        }
-    }
-    return getNodeDefinitions(node)[0]?.getDeclarationNode() ?? node;
-}
-function getComponentIdentity(func) {
-    return `${func.getSourceFile().getFilePath()}:${func.getStart()}`;
-}
-function resolveForwardedComponentIdentity(tagNameNode) {
-    if (!Node.isIdentifier(tagNameNode))
-        return undefined;
-    for (const declaration of getValueTargetDeclarations(tagNameNode)) {
-        const func = resolveFunctionNode(declaration);
-        if (func)
-            return getComponentIdentity(func);
-    }
-    return undefined;
-}
-/**
- * Declarations that are rebound somewhere in the body, so their initializer no
- * longer describes the value that reaches JSX.
- */
-function collectReboundDeclarations(body) {
-    const rebound = new Set();
-    const recordTarget = (target) => {
-        if (Node.isIdentifier(target)) {
-            rebound.add(getDeclarationIdentity(target));
-            return;
-        }
-        if ((Node.isPropertyAccessExpression(target) || Node.isElementAccessExpression(target)) &&
-            Node.isIdentifier(target.getExpression())) {
-            rebound.add(getDeclarationIdentity(target.getExpression()));
-        }
-    };
-    for (const assignment of body?.getDescendantsOfKind(SyntaxKind.BinaryExpression) ?? []) {
-        // Covers `=` and every compound form (`+=`, `??=`, `>>>=`, ...).
-        const operator = assignment.getOperatorToken().getKind();
-        if (operator < SyntaxKind.FirstAssignment || operator > SyntaxKind.LastAssignment)
-            continue;
-        recordTarget(assignment.getLeft());
-    }
-    // Only `++`/`--` rebind the operand. Reading a prop through `!`, `-`, `+`, or
-    // `~` leaves the alias intact, so those operators must not invalidate it.
-    for (const update of body?.getDescendantsOfKind(SyntaxKind.PrefixUnaryExpression) ?? []) {
-        const operator = update.getOperatorToken();
-        if (operator !== SyntaxKind.PlusPlusToken && operator !== SyntaxKind.MinusMinusToken)
-            continue;
-        recordTarget(update.getOperand());
-    }
-    for (const update of body?.getDescendantsOfKind(SyntaxKind.PostfixUnaryExpression) ?? []) {
-        recordTarget(update.getOperand());
-    }
-    return rebound;
-}
-/** Trace only statically resolvable, component-local prop dataflow into JSX. */
-function collectPropDataflow(func, param, availablePropNames) {
-    const valueAliases = new Map();
-    const objectAliases = new Map();
-    const fullPropsShape = new Map([...availablePropNames].map((name) => [name, name]));
-    const belongsToComponentFunction = (node) => node.getFirstAncestor((ancestor) => Node.isFunctionDeclaration(ancestor) || Node.isArrowFunction(ancestor) || Node.isFunctionExpression(ancestor)) === func;
-    const resolveValue = (expression) => {
-        if (!expression)
-            return undefined;
-        if (Node.isParenthesizedExpression(expression))
-            return resolveValue(expression.getExpression());
-        if (Node.isIdentifier(expression))
-            return valueAliases.get(getDeclarationIdentity(expression));
-        if (Node.isPropertyAccessExpression(expression)) {
-            const object = expression.getExpression();
-            return Node.isIdentifier(object)
-                ? objectAliases.get(getDeclarationIdentity(object))?.get(expression.getName())
-                : undefined;
-        }
-        if (Node.isElementAccessExpression(expression)) {
-            const argument = expression.getArgumentExpression();
-            if (!argument || (!Node.isStringLiteral(argument) && !Node.isNoSubstitutionTemplateLiteral(argument))) {
-                return undefined;
-            }
-            const object = expression.getExpression();
-            return Node.isIdentifier(object)
-                ? objectAliases.get(getDeclarationIdentity(object))?.get(argument.getLiteralText())
-                : undefined;
-        }
-        return undefined;
-    };
-    const resolveObject = (expression) => {
-        if (!expression)
-            return undefined;
-        if (Node.isParenthesizedExpression(expression))
-            return resolveObject(expression.getExpression());
-        if (Node.isIdentifier(expression))
-            return objectAliases.get(getDeclarationIdentity(expression));
-        if (!Node.isObjectLiteralExpression(expression))
-            return undefined;
-        const shape = new Map();
-        for (const property of expression.getProperties()) {
-            if (Node.isSpreadAssignment(property)) {
-                const spreadShape = resolveObject(property.getExpression());
-                for (const [targetProp, sourceProp] of spreadShape ?? [])
-                    shape.set(targetProp, sourceProp);
-            }
-            else if (Node.isShorthandPropertyAssignment(property)) {
-                const sourceProp = resolveValue(property.getNameNode());
-                if (sourceProp)
-                    shape.set(property.getName(), sourceProp);
-            }
-            else if (Node.isPropertyAssignment(property)) {
-                const propertyNameNode = property.getNameNode();
-                if (!Node.isIdentifier(propertyNameNode) && !Node.isStringLiteral(propertyNameNode))
-                    continue;
-                const sourceProp = resolveValue(property.getInitializer());
-                if (sourceProp)
-                    shape.set(property.getName(), sourceProp);
-            }
-        }
-        return shape;
-    };
-    const addBindings = (pattern, sourceShape) => {
-        const omittedProps = new Set(pattern
-            .getElements()
-            .filter((element) => !element.getDotDotDotToken())
-            .map((element) => element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText()));
-        for (const element of pattern.getElements()) {
-            const localName = element.getNameNode();
-            if (!Node.isIdentifier(localName))
-                continue;
-            if (element.getDotDotDotToken()) {
-                objectAliases.set(getDeclarationIdentity(localName), new Map([...sourceShape].filter(([targetProp]) => !omittedProps.has(targetProp))));
-                continue;
-            }
-            const targetProp = element.getPropertyNameNode()?.getText() ?? localName.getText();
-            const sourceProp = sourceShape.get(targetProp);
-            if (sourceProp)
-                valueAliases.set(getDeclarationIdentity(localName), sourceProp);
-        }
-    };
-    const paramNameNode = param.getNameNode();
-    if (Node.isIdentifier(paramNameNode))
-        objectAliases.set(getDeclarationIdentity(paramNameNode), fullPropsShape);
-    else if (Node.isObjectBindingPattern(paramNameNode))
-        addBindings(paramNameNode, fullPropsShape);
-    const body = func.getBody();
-    const reboundDeclarations = collectReboundDeclarations(body);
-    for (const declaration of reboundDeclarations) {
-        valueAliases.delete(declaration);
-        objectAliases.delete(declaration);
-    }
-    for (const declaration of body?.getDescendantsOfKind(SyntaxKind.VariableDeclaration) ?? []) {
-        if (!belongsToComponentFunction(declaration))
-            continue;
-        const initializer = declaration.getInitializer();
-        const declarationName = declaration.getNameNode();
-        if (Node.isIdentifier(declarationName)) {
-            const aliasDeclaration = getDeclarationIdentity(declarationName);
-            if (reboundDeclarations.has(aliasDeclaration))
-                continue;
-            const sourceProp = resolveValue(initializer);
-            if (sourceProp)
-                valueAliases.set(aliasDeclaration, sourceProp);
-            const sourceShape = resolveObject(initializer);
-            if (sourceShape)
-                objectAliases.set(aliasDeclaration, new Map(sourceShape));
-        }
-        else if (Node.isObjectBindingPattern(declarationName)) {
-            const sourceShape = resolveObject(initializer);
-            if (sourceShape) {
-                const hasInvalidatedBinding = declarationName
-                    .getElements()
-                    .some((element) => reboundDeclarations.has(getDeclarationIdentity(element.getNameNode())));
-                if (!hasInvalidatedBinding)
-                    addBindings(declarationName, sourceShape);
-            }
-        }
-    }
-    const intrinsicDomProps = new Set();
-    const componentEdges = [];
-    const recordForwarding = (tagNameNode, targetProp, sourceProp) => {
-        const tagName = tagNameNode.getText();
-        if (isIntrinsicJsxElement(tagName)) {
-            if (targetProp === sourceProp)
-                intrinsicDomProps.add(sourceProp);
-            return;
-        }
-        const targetComponentIdentity = resolveForwardedComponentIdentity(tagNameNode);
-        if (targetComponentIdentity)
-            componentEdges.push({ sourceProp, targetComponentIdentity, targetProp });
-    };
-    for (const attribute of func.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
-        if (!belongsToComponentFunction(attribute))
-            continue;
-        const tagNameNode = getJsxTagNameNode(attribute);
-        if (!tagNameNode)
-            continue;
-        const initializer = attribute.getInitializer();
-        if (!initializer || !Node.isJsxExpression(initializer))
-            continue;
-        const sourceProp = resolveValue(initializer.getExpression());
-        if (sourceProp)
-            recordForwarding(tagNameNode, attribute.getNameNode().getText(), sourceProp);
-    }
-    for (const spread of func.getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)) {
-        if (!belongsToComponentFunction(spread))
-            continue;
-        const tagNameNode = getJsxTagNameNode(spread);
-        if (!tagNameNode)
-            continue;
-        const shape = resolveObject(spread.getExpression());
-        for (const [targetProp, sourceProp] of shape ?? [])
-            recordForwarding(tagNameNode, targetProp, sourceProp);
-    }
-    return { intrinsicDomProps, componentEdges };
-}
 function extractDestructuredBindingFallbackProps(func, param, existingPropNames, slotNames) {
     const nameNode = param.getNameNode();
     const bindingPatterns = [];
@@ -1663,8 +1448,8 @@ export async function extractReactComponents(filePaths) {
             }
         }
     }
-    // Structural evidence (usage, not a declared slot contract) — see
-    // structural-slot-evidence.ts. Only fills slots the typed-slot pass above
+    // Structural evidence (usage, not a declared slot contract) — see the
+    // structural slot evidence pass. Only fills slots the typed-slot pass above
     // found nothing for; a declared contract always takes precedence. File-wide
     // signals (type-predicate functions, `.type === Component` identity checks)
     // are computed once per file and shared across every component in it, since
@@ -1938,132 +1723,3 @@ function extractPropTypes(sourceFile, componentName) {
     }
     return undefined;
 }
-function resolveFunctionNode(decl) {
-    if (Node.isFunctionDeclaration(decl))
-        return decl;
-    if (Node.isArrowFunction(decl))
-        return decl;
-    if (Node.isFunctionExpression(decl))
-        return decl;
-    if (Node.isVariableDeclaration(decl)) {
-        const init = decl.getInitializer();
-        if (init && Node.isArrowFunction(init))
-            return init;
-        if (init && Node.isFunctionExpression(init))
-            return init;
-        if (init && Node.isCallExpression(init))
-            return resolveFunctionFromCallExpression(init, new Set());
-    }
-    return undefined;
-}
-function resolveBestFunctionNode(declarations) {
-    const candidates = declarations
-        .map((decl) => resolveFunctionNode(decl))
-        .filter((candidate) => candidate !== undefined);
-    const implementation = candidates.find((candidate) => !Node.isFunctionDeclaration(candidate) || candidate.getBody() !== undefined);
-    return implementation ?? candidates[0];
-}
-function resolveForwardRefFunction(callExpr) {
-    if (!Node.isCallExpression(callExpr))
-        return undefined;
-    const expressionText = callExpr.getExpression().getText();
-    if (!/(^|\.)forwardRef$/.test(expressionText))
-        return undefined;
-    const firstArg = callExpr.getArguments()[0];
-    if (!firstArg)
-        return undefined;
-    if (Node.isArrowFunction(firstArg))
-        return firstArg;
-    if (Node.isFunctionExpression(firstArg))
-        return firstArg;
-    if (Node.isIdentifier(firstArg)) {
-        const declarations = getNodeDefinitions(firstArg).flatMap((definition) => {
-            const declarationNode = definition.getDeclarationNode();
-            return declarationNode ? [declarationNode] : [];
-        });
-        for (const declaration of declarations) {
-            const resolved = resolveFunctionNode(declaration);
-            if (resolved)
-                return resolved;
-        }
-    }
-    return undefined;
-}
-function resolveFunctionFromCallExpression(callExpr, seen) {
-    return resolveForwardRefFunction(callExpr) ?? resolveReturnedFunctionFromFactoryCall(callExpr, seen);
-}
-function resolveReturnedFunctionFromFactoryCall(callExpr, seen) {
-    const expression = callExpr.getExpression();
-    if (!Node.isIdentifier(expression))
-        return undefined;
-    for (const definition of getNodeDefinitions(expression)) {
-        const declaration = definition.getDeclarationNode();
-        if (!declaration)
-            continue;
-        const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
-        if (resolved)
-            return resolved;
-    }
-    return undefined;
-}
-function resolveReturnedFunctionFromDeclaration(node, seen) {
-    if (seen.has(node))
-        return undefined;
-    seen.add(node);
-    if (Node.isVariableDeclaration(node)) {
-        const initializer = node.getInitializer();
-        if (!initializer)
-            return undefined;
-        if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
-            return resolveReturnedFunctionFromCallable(initializer, seen);
-        }
-        if (Node.isCallExpression(initializer)) {
-            return resolveFunctionFromCallExpression(initializer, seen);
-        }
-        return undefined;
-    }
-    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
-        return resolveReturnedFunctionFromCallable(node, seen);
-    }
-    return undefined;
-}
-function resolveReturnedFunctionFromCallable(fn, seen) {
-    const body = fn.getBody();
-    if (!body)
-        return undefined;
-    if (!Node.isBlock(body)) {
-        return resolveReturnedFunctionFromExpression(body, seen);
-    }
-    for (const statement of body.getStatements()) {
-        if (!Node.isReturnStatement(statement))
-            continue;
-        const expression = statement.getExpression();
-        if (!expression)
-            continue;
-        const resolved = resolveReturnedFunctionFromExpression(expression, seen);
-        if (resolved)
-            return resolved;
-    }
-    return undefined;
-}
-function resolveReturnedFunctionFromExpression(node, seen) {
-    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node))
-        return node;
-    if (Node.isParenthesizedExpression(node)) {
-        return resolveReturnedFunctionFromExpression(node.getExpression(), seen);
-    }
-    if (Node.isCallExpression(node)) {
-        return resolveFunctionFromCallExpression(node, seen);
-    }
-    if (Node.isIdentifier(node)) {
-        for (const definition of getNodeDefinitions(node)) {
-            const declaration = definition.getDeclarationNode();
-            if (!declaration)
-                continue;
-            const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
-            if (resolved)
-                return resolved;
-        }
-    }
-    return undefined;
-}

package/dist/src/extract/adapters/react/function-resolution.d.ts

@@ -0,0 +1,4 @@
+import { Node, type ArrowFunction, type FunctionDeclaration, type FunctionExpression } from 'ts-morph';
+export type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression;
+export declare function resolveFunctionNode(decl: Node): FunctionLike | undefined;
+export declare function resolveBestFunctionNode(declarations: Node[]): FunctionLike | undefined;

package/dist/src/extract/adapters/react/function-resolution.js

@@ -0,0 +1,131 @@
+import { Node, } from 'ts-morph';
+import { getNodeDefinitions } from '../support/tsx-shared.js';
+export function resolveFunctionNode(decl) {
+    if (Node.isFunctionDeclaration(decl))
+        return decl;
+    if (Node.isArrowFunction(decl))
+        return decl;
+    if (Node.isFunctionExpression(decl))
+        return decl;
+    if (Node.isVariableDeclaration(decl)) {
+        const init = decl.getInitializer();
+        if (init && Node.isArrowFunction(init))
+            return init;
+        if (init && Node.isFunctionExpression(init))
+            return init;
+        if (init && Node.isCallExpression(init))
+            return resolveFunctionFromCallExpression(init, new Set());
+    }
+    return undefined;
+}
+export function resolveBestFunctionNode(declarations) {
+    const candidates = declarations
+        .map((decl) => resolveFunctionNode(decl))
+        .filter((candidate) => candidate !== undefined);
+    const implementation = candidates.find((candidate) => !Node.isFunctionDeclaration(candidate) || candidate.getBody() !== undefined);
+    return implementation ?? candidates[0];
+}
+function resolveForwardRefFunction(callExpr) {
+    if (!Node.isCallExpression(callExpr))
+        return undefined;
+    const expressionText = callExpr.getExpression().getText();
+    if (!/(^|\.)forwardRef$/.test(expressionText))
+        return undefined;
+    const firstArg = callExpr.getArguments()[0];
+    if (!firstArg)
+        return undefined;
+    if (Node.isArrowFunction(firstArg))
+        return firstArg;
+    if (Node.isFunctionExpression(firstArg))
+        return firstArg;
+    if (Node.isIdentifier(firstArg)) {
+        const declarations = getNodeDefinitions(firstArg).flatMap((definition) => {
+            const declarationNode = definition.getDeclarationNode();
+            return declarationNode ? [declarationNode] : [];
+        });
+        for (const declaration of declarations) {
+            const resolved = resolveFunctionNode(declaration);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}
+function resolveFunctionFromCallExpression(callExpr, seen) {
+    return resolveForwardRefFunction(callExpr) ?? resolveReturnedFunctionFromFactoryCall(callExpr, seen);
+}
+function resolveReturnedFunctionFromFactoryCall(callExpr, seen) {
+    const expression = callExpr.getExpression();
+    if (!Node.isIdentifier(expression))
+        return undefined;
+    for (const definition of getNodeDefinitions(expression)) {
+        const declaration = definition.getDeclarationNode();
+        if (!declaration)
+            continue;
+        const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromDeclaration(node, seen) {
+    if (seen.has(node))
+        return undefined;
+    seen.add(node);
+    if (Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (!initializer)
+            return undefined;
+        if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
+            return resolveReturnedFunctionFromCallable(initializer, seen);
+        }
+        if (Node.isCallExpression(initializer)) {
+            return resolveFunctionFromCallExpression(initializer, seen);
+        }
+        return undefined;
+    }
+    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
+        return resolveReturnedFunctionFromCallable(node, seen);
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromCallable(fn, seen) {
+    const body = fn.getBody();
+    if (!body)
+        return undefined;
+    if (!Node.isBlock(body)) {
+        return resolveReturnedFunctionFromExpression(body, seen);
+    }
+    for (const statement of body.getStatements()) {
+        if (!Node.isReturnStatement(statement))
+            continue;
+        const expression = statement.getExpression();
+        if (!expression)
+            continue;
+        const resolved = resolveReturnedFunctionFromExpression(expression, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromExpression(node, seen) {
+    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node))
+        return node;
+    if (Node.isParenthesizedExpression(node)) {
+        return resolveReturnedFunctionFromExpression(node.getExpression(), seen);
+    }
+    if (Node.isCallExpression(node)) {
+        return resolveFunctionFromCallExpression(node, seen);
+    }
+    if (Node.isIdentifier(node)) {
+        for (const definition of getNodeDefinitions(node)) {
+            const declaration = definition.getDeclarationNode();
+            if (!declaration)
+                continue;
+            const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}

package/dist/src/extract/adapters/react/prop-dataflow.d.ts

@@ -0,0 +1,14 @@
+import { type ParameterDeclaration } from 'ts-morph';
+import { type FunctionLike } from './function-resolution.js';
+export type PropForwardingEdge = {
+    sourceProp: string;
+    targetComponentIdentity: string;
+    targetProp: string;
+};
+export type PropDataflow = {
+    intrinsicDomProps: Set<string>;
+    componentEdges: PropForwardingEdge[];
+};
+export declare function getComponentIdentity(func: FunctionLike): string;
+/** Trace only statically resolvable, component-local prop dataflow into JSX. */
+export declare function collectPropDataflow(func: FunctionLike, param: ParameterDeclaration, availablePropNames: Set<string>): PropDataflow;