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

package/dist/src/extract/{adapters/web-components/extractor.js → web-components.js}

@@ -1,9 +1,7 @@
 import { basename, dirname, join, resolve } from 'node:path';
 import { Project, Node, SyntaxKind } from 'ts-morph';
-import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
-import { extractProjectSourceFiles } from '../support/file-processing/project-source-files.js';
-import { kebabToPascal } from '../support/tsx-shared.js';
-import { extractAccessorProperties, extractClassProperties, extractJsDocAttributeProps, extractObservedAttributes, hasShoelaceRuntimeBookkeepingField, mergePropLists, mergeProps, } from './properties.js';
+import { createSortedExtractionResult, extractProjectSourceFiles } from './file-extraction-workers.js';
+import { kebabToPascal } from './tsx-shared.js';
 function normalizeComponentName(input) {
     return input.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
 }
@@ -13,6 +11,9 @@ function camelToKebab(input) {
         .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
         .toLowerCase();
 }
+function kebabToCamel(input) {
+    return input.replace(/-([a-z0-9])/gi, (_, char) => char.toUpperCase());
+}
 function resolveDecoratorInterpolation(node) {
     if (Node.isIdentifier(node)) {
         const definitions = node.getDefinitions();
@@ -261,6 +262,214 @@ function extractJsDocSlots(classDecl) {
     }
     return mergeSlotLists(slots);
 }
+function extractObservedAttributes(classDecl) {
+    const props = [];
+    const getter = classDecl.getGetAccessor('observedAttributes');
+    if (!getter || !getter.isStatic())
+        return props;
+    const body = getter.getBody();
+    if (!body)
+        return props;
+    // Find the return statement containing an array literal
+    body.forEachDescendant((node) => {
+        if (!Node.isReturnStatement(node))
+            return;
+        const expression = node.getExpression();
+        if (!expression || !Node.isArrayLiteralExpression(expression))
+            return;
+        for (const element of expression.getElements()) {
+            if (Node.isStringLiteral(element)) {
+                const attrName = element.getLiteralValue();
+                props.push({
+                    name: attrName,
+                    type: 'string',
+                    required: false,
+                });
+            }
+        }
+    });
+    return props;
+}
+function hasInternalJsDocTag(member) {
+    return member.getJsDocs().some((doc) => doc.getTags().some((tag) => tag.getTagName() === 'internal'));
+}
+const NON_PUBLIC_LIT_DECORATORS = new Set(['consume', 'provide', 'query', 'queryAsync', 'state']);
+const INTERNAL_RUNTIME_FIELD_NAMES = new Set(['dir', 'initialReflectedProperties', 'lang']);
+function isNonPublicLitMember(member) {
+    return member.getDecorators().some((decorator) => NON_PUBLIC_LIT_DECORATORS.has(decorator.getName()));
+}
+function hasShoelaceRuntimeBookkeepingField(classDecl) {
+    return classDecl.getProperties().some((property) => property.getName() === 'initialReflectedProperties');
+}
+function isInternalRuntimeField(name, applyRuntimeFieldDenylist) {
+    return applyRuntimeFieldDenylist && INTERNAL_RUNTIME_FIELD_NAMES.has(name);
+}
+function getExplicitLitPropertyAttributeName(property) {
+    const decorator = property.getDecorators().find((candidate) => candidate.getName() === 'property');
+    const firstArg = decorator?.getArguments()[0];
+    if (!firstArg || !Node.isObjectLiteralExpression(firstArg)) {
+        return null;
+    }
+    const attributeProp = firstArg.getProperty('attribute');
+    if (!attributeProp || !Node.isPropertyAssignment(attributeProp)) {
+        return null;
+    }
+    const initializer = attributeProp.getInitializer();
+    if (!initializer || !Node.isStringLiteral(initializer)) {
+        return null;
+    }
+    return initializer.getLiteralValue();
+}
+function extractClassProperties(classDecl, applyRuntimeFieldDenylist = false) {
+    const props = [];
+    for (const property of classDecl.getProperties()) {
+        if (property.isStatic())
+            continue;
+        if (hasInternalJsDocTag(property))
+            continue;
+        if (isNonPublicLitMember(property))
+            continue;
+        const name = property.getName();
+        if (name.startsWith('#') || isInternalRuntimeField(name, applyRuntimeFieldDenylist))
+            continue;
+        const scope = property.getScope();
+        if (scope === 'private' || scope === 'protected')
+            continue;
+        const initializer = property.getInitializer();
+        const hasDecorators = property.getDecorators().length > 0;
+        // Skip undecorated arrow-function properties (internal event handlers / callbacks)
+        if (!hasDecorators && initializer && Node.isArrowFunction(initializer)) {
+            continue;
+        }
+        // Skip properties initialized with this.attachInternals() (ElementInternals)
+        if (initializer &&
+            Node.isCallExpression(initializer) &&
+            initializer.getExpression().getText() === 'this.attachInternals') {
+            continue;
+        }
+        const typeNode = property.getTypeNode();
+        const type = typeNode ? typeNode.getText() : 'any';
+        const publicName = name.startsWith('_') && hasDecorators ? getExplicitLitPropertyAttributeName(property) : null;
+        let defaultValue;
+        if (initializer) {
+            if (Node.isStringLiteral(initializer)) {
+                defaultValue = initializer.getLiteralValue();
+            }
+            else {
+                defaultValue = initializer.getText();
+            }
+        }
+        props.push({
+            name: publicName ? kebabToCamel(publicName) : name,
+            type,
+            required: false,
+            ...(defaultValue !== undefined && { defaultValue }),
+            sourceStartLine: property.getStartLineNumber(),
+            sourceEndLine: property.getEndLineNumber(),
+        });
+    }
+    return props;
+}
+function extractAccessorProperties(classDecl, applyRuntimeFieldDenylist = false) {
+    const props = [];
+    const accessors = new Map();
+    for (const getter of classDecl.getGetAccessors()) {
+        if (getter.isStatic())
+            continue;
+        if (hasInternalJsDocTag(getter))
+            continue;
+        if (isNonPublicLitMember(getter))
+            continue;
+        const name = getter.getName();
+        if (name === 'observedAttributes' ||
+            name === 'template' ||
+            name.startsWith('#') ||
+            isInternalRuntimeField(name, applyRuntimeFieldDenylist))
+            continue;
+        const scope = getter.getScope();
+        if (scope === 'private' || scope === 'protected')
+            continue;
+        const entry = accessors.get(name) ?? {};
+        entry.getter = getter;
+        accessors.set(name, entry);
+    }
+    for (const setter of classDecl.getSetAccessors()) {
+        if (setter.isStatic())
+            continue;
+        if (hasInternalJsDocTag(setter))
+            continue;
+        if (isNonPublicLitMember(setter))
+            continue;
+        const name = setter.getName();
+        if (name === 'observedAttributes' ||
+            name === 'template' ||
+            name.startsWith('#') ||
+            isInternalRuntimeField(name, applyRuntimeFieldDenylist))
+            continue;
+        const scope = setter.getScope();
+        if (scope === 'private' || scope === 'protected')
+            continue;
+        const entry = accessors.get(name) ?? {};
+        entry.setter = setter;
+        accessors.set(name, entry);
+    }
+    for (const [name, { getter, setter }] of accessors) {
+        const hasPropertyDecorator = getter?.getDecorators().some((decorator) => decorator.getName() === 'property') ||
+            setter?.getDecorators().some((decorator) => decorator.getName() === 'property');
+        if (!hasPropertyDecorator && !(getter && setter))
+            continue;
+        const type = getter?.getReturnTypeNode()?.getText() ?? setter?.getParameters()[0]?.getTypeNode()?.getText() ?? 'any';
+        const accessorNode = getter ?? setter;
+        props.push({
+            name,
+            type,
+            required: false,
+            ...(accessorNode
+                ? {
+                    sourceStartLine: accessorNode.getStartLineNumber(),
+                    sourceEndLine: accessorNode.getEndLineNumber(),
+                }
+                : {}),
+        });
+    }
+    return props;
+}
+function extractJsDocAttributeProps(classDecl) {
+    const props = [];
+    for (const doc of classDecl.getJsDocs()) {
+        for (const tag of doc.getTags()) {
+            if (tag.getTagName() !== 'attribute')
+                continue;
+            const tagComment = tag.getCommentText();
+            const normalizedComment = Array.isArray(tagComment) ? tagComment.join(' ') : tagComment;
+            const match = normalizedComment?.match(/(?:\{([^}]+)\}\s+)?([^\s]+)(?:\s*-\s*([\s\S]*))?/);
+            if (!match)
+                continue;
+            const [, type, name, description] = match;
+            if (!name || name.startsWith('#'))
+                continue;
+            props.push({
+                name,
+                type: type?.trim() || 'any',
+                required: false,
+                ...(description ? { description: description.replace(/\s+/g, ' ').trim() } : {}),
+            });
+        }
+    }
+    return props;
+}
+function mergePropLists(...propLists) {
+    const merged = new Map();
+    for (const propList of propLists) {
+        for (const prop of propList) {
+            merged.set(prop.name, prop);
+        }
+    }
+    return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function mergeProps(observed, classProps) {
+    return mergePropLists(observed, classProps);
+}
 function collectHtmlTaggedTemplates(root) {
     const templates = [];
     root.forEachDescendant((node) => {

package/dist/src/index.d.ts

@@ -1,25 +1,21 @@
-export type { RawComponentDefinition, RawPropDefinition, RawSlotDefinition, ComponentExtractionResult, ExtractionExclusion, ExtractorProgress, ExtractionValidationIssue, ExtractionValidationIssueCode, } from './extract/model/component.js';
-export { stripScoringFields } from './extract/model/component.js';
-export type { ExtractorOptions } from './extract/model/options.js';
-export type { ComponentExtractor } from './extract/services/ports/component-extractor.js';
-export { extractComponents } from './extract/services/extraction-pipeline.js';
-export { extractEndpoint } from './extract/controller/extract-controller.js';
-export type { ExtractionEndpointProgress, ExtractionEndpointRequest, ExtractionEndpointResponse, } from './extract/model/contract.js';
-export { extractReactComponents } from './extract/adapters/react/extractor.js';
-export { extractVueComponents } from './extract/adapters/vue/extractor.js';
-export { extractVueTsxComponents } from './extract/adapters/vue-tsx/extractor.js';
-export { extractStencilComponents } from './extract/adapters/stencil/extractor.js';
-export { extractAstroComponents } from './extract/adapters/astro/extractor.js';
-export { extractWebComponentDefinitions } from './extract/adapters/web-components/extractor.js';
-export { extractSvelteComponents } from './extract/adapters/svelte/extractor.js';
-export { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from './extract/evidence/allowed-components.js';
-export { isNonAuthorableComponent } from './extract/policies/quality/authorability.js';
-export { computeExtractionScore, deriveNeedsReview } from './extract/policies/quality/scoring.js';
-export type { ExtractionScore, ExtractionScoreOptions, ExtractionConfidence } from './extract/model/scoring.js';
-export { inspectComponentSource, describeReviewReasons, describeReviewReason, isDataWrapperReviewReason, HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON, POSSIBLE_DATA_FETCH_WRAPPER_REASON, ZERO_SURFACE_RENDERED_UI_REASON, } from './extract/policies/quality/source-inspection.js';
-export type { ComponentSourceInspection } from './extract/policies/quality/source-inspection.js';
-export { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, formatExcludedComponentLines, } from './extract/policies/quality/validation.js';
-export { parseImportedNames } from './extract/evidence/source-evidence.js';
-export { CONTENT_NAME_EXCEPTIONS, isReactNodeType, isArrayReactNodeType, shouldBeSlot, } from './extract/evidence/slot-evidence.js';
-export { preClassifyProp, preClassifyComponent } from './extract/services/classification-service.js';
-export type { PreClassification } from './extract/services/classification-service.js';
+export type { RawComponentDefinition, RawPropDefinition, RawSlotDefinition, ComponentExtractionResult, ExtractionExclusion, ExtractorProgress, ExtractorOptions, ComponentExtractor, ExtractionValidationIssue, ExtractionValidationIssueCode, } from './types.js';
+export { stripScoringFields } from './types.js';
+export { extractComponents } from './extract/pipeline.js';
+export { extractReactComponents } from './extract/react.js';
+export { extractVueComponents } from './extract/vue.js';
+export { extractVueTsxComponents } from './extract/vue-tsx.js';
+export { extractStencilComponents } from './extract/stencil.js';
+export { extractAstroComponents } from './extract/astro.js';
+export { extractWebComponentDefinitions } from './extract/web-components.js';
+export { extractSvelteComponents } from './extract/svelte.js';
+export { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from './extract/slot-allowed-components.js';
+export { isNonAuthorableComponent } from './extract/non-authorable-filter.js';
+export { computeExtractionScore, deriveNeedsReview } from './extract/scoring.js';
+export type { ExtractionScore, ExtractionScoreOptions, ExtractionConfidence } from './extract/scoring.js';
+export { inspectComponentSource, describeReviewReasons, describeReviewReason, isDataWrapperReviewReason, HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON, POSSIBLE_DATA_FETCH_WRAPPER_REASON, ZERO_SURFACE_RENDERED_UI_REASON, } from './extract/source-inspection.js';
+export type { ComponentSourceInspection } from './extract/source-inspection.js';
+export { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, formatExcludedComponentLines, } from './extract/validate.js';
+export { parseImportedNames } from './extract/parse-imported-names.js';
+export { CONTENT_NAME_EXCEPTIONS, isReactNodeType, isArrayReactNodeType, shouldBeSlot, } from './extract/slot-detection.js';
+export { preClassifyProp, preClassifyComponent } from './pre-classify.js';
+export type { PreClassification } from './pre-classify.js';

package/dist/src/index.js

@@ -1,24 +1,23 @@
-export { stripScoringFields } from './extract/model/component.js';
+export { stripScoringFields } from './types.js';
 // Core extraction pipeline
-export { extractComponents } from './extract/services/extraction-pipeline.js';
-export { extractEndpoint } from './extract/controller/extract-controller.js';
+export { extractComponents } from './extract/pipeline.js';
 // Framework-specific extractors
-export { extractReactComponents } from './extract/adapters/react/extractor.js';
-export { extractVueComponents } from './extract/adapters/vue/extractor.js';
-export { extractVueTsxComponents } from './extract/adapters/vue-tsx/extractor.js';
-export { extractStencilComponents } from './extract/adapters/stencil/extractor.js';
-export { extractAstroComponents } from './extract/adapters/astro/extractor.js';
-export { extractWebComponentDefinitions } from './extract/adapters/web-components/extractor.js';
-export { extractSvelteComponents } from './extract/adapters/svelte/extractor.js';
-export { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from './extract/evidence/allowed-components.js';
+export { extractReactComponents } from './extract/react.js';
+export { extractVueComponents } from './extract/vue.js';
+export { extractVueTsxComponents } from './extract/vue-tsx.js';
+export { extractStencilComponents } from './extract/stencil.js';
+export { extractAstroComponents } from './extract/astro.js';
+export { extractWebComponentDefinitions } from './extract/web-components.js';
+export { extractSvelteComponents } from './extract/svelte.js';
+export { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from './extract/slot-allowed-components.js';
 // Post-extraction filtering and scoring
-export { isNonAuthorableComponent } from './extract/policies/quality/authorability.js';
-export { computeExtractionScore, deriveNeedsReview } from './extract/policies/quality/scoring.js';
-export { inspectComponentSource, describeReviewReasons, describeReviewReason, isDataWrapperReviewReason, HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON, POSSIBLE_DATA_FETCH_WRAPPER_REASON, ZERO_SURFACE_RENDERED_UI_REASON, } from './extract/policies/quality/source-inspection.js';
+export { isNonAuthorableComponent } from './extract/non-authorable-filter.js';
+export { computeExtractionScore, deriveNeedsReview } from './extract/scoring.js';
+export { inspectComponentSource, describeReviewReasons, describeReviewReason, isDataWrapperReviewReason, HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON, POSSIBLE_DATA_FETCH_WRAPPER_REASON, ZERO_SURFACE_RENDERED_UI_REASON, } from './extract/source-inspection.js';
 // Validation
-export { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, formatExcludedComponentLines, } from './extract/policies/quality/validation.js';
-export { parseImportedNames } from './extract/evidence/source-evidence.js';
+export { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, formatExcludedComponentLines, } from './extract/validate.js';
+export { parseImportedNames } from './extract/parse-imported-names.js';
 // Slot detection helpers
-export { CONTENT_NAME_EXCEPTIONS, isReactNodeType, isArrayReactNodeType, shouldBeSlot, } from './extract/evidence/slot-evidence.js';
+export { CONTENT_NAME_EXCEPTIONS, isReactNodeType, isArrayReactNodeType, shouldBeSlot, } from './extract/slot-detection.js';
 // Pre-classification
-export { preClassifyProp, preClassifyComponent } from './extract/services/classification-service.js';
+export { preClassifyProp, preClassifyComponent } from './pre-classify.js';

package/dist/src/{extract/services/classification-service.d.ts → pre-classify.d.ts}

@@ -1,4 +1,4 @@
-import type { RawPropDefinition, RawComponentDefinition } from '../model/component.js';
+import type { RawPropDefinition, RawComponentDefinition } from './types.js';
 export interface PreClassification {
     category: 'content' | 'design' | 'state' | 'exclude';
     cdfTypeHint?: 'string' | 'enum' | 'richtext' | 'media' | 'boolean';

package/dist/src/{extract/model/component.d.ts → types.d.ts}

@@ -76,5 +76,25 @@ export type ExtractorProgress = {
     filesProcessed: number;
     componentsFound: number;
 };
+/**
+ * Optional extraction-time settings forwarded from the CLI through the
+ * pipeline to each extractor. Only the Svelte extractor currently consumes
+ * any of these; other extractors ignore the value.
+ */
+export interface ExtractorOptions {
+    /**
+     * Whether the Svelte extractor should run a retry pass for components whose
+     * declared Props type couldn't be resolved on the first pass (cross-package
+     * extends, path-alias-only types, etc.). See svelte.ts for the policy.
+     */
+    resolveUnreachable?: 'auto' | 'always' | 'never';
+    /** Absolute project root — used by the retry pass to locate tsconfig.json and node_modules. */
+    projectRoot?: string;
+}
+export interface ComponentExtractor {
+    name: string;
+    fileFilter: (filePath: string) => boolean;
+    extract(filePaths: string[], onProgress?: (p: ExtractorProgress) => void, opts?: ExtractorOptions): Promise<ComponentExtractionResult>;
+}
 /** Strip internal scoring fields before serialising a RawComponentDefinition for display or editing. */
 export declare function stripScoringFields({ extractionConfidence: _c, reviewReasons: _r, needsReview: _n, ...rest }: RawComponentDefinition): Omit<RawComponentDefinition, 'extractionConfidence' | 'reviewReasons' | 'needsReview'>;

package/package.json

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

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

@@ -1,4 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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;