@contentful/experience-design-system-extraction 2.36.2-dev-build-a6f80ae6.0 → 2.36.2-dev-build-450d231a.0

package/dist/src/extract/framework-adapters/react/helpers/detect-react-polymorphic.js

@@ -0,0 +1,170 @@
+import { Node } from 'ts-morph';
+import { getTypeReferenceName, getTypeTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
+import { getTypeReferenceTargetNode, getTypeReferenceArguments } from '../../shared/helpers/tsx-node-utils.js';
+export const TRANSPARENT_POLYMORPHIC_TYPE_NAMES = new Set(['PolymorphicProps', 'PropsWithAs', 'PropsWithHTMLElement']);
+export function isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, typeName) {
+    if (!Node.isTypeAliasDeclaration(declaration))
+        return false;
+    if (declaration.getSourceFile().getFilePath().includes('/node_modules/'))
+        return false;
+    if (!TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName))
+        return false;
+    const typeParameters = declaration.getTypeParameters();
+    const typeNode = declaration.getTypeNode();
+    if (!typeNode)
+        return false;
+    if (typeName === 'PropsWithAs') {
+        if (typeParameters.length !== 2 || !Node.isIntersectionTypeNode(typeNode))
+            return false;
+        const [propsTypeNode, wrapperTypeNode] = typeNode.getTypeNodes();
+        if (!propsTypeNode || !wrapperTypeNode)
+            return false;
+        if (propsTypeNode.getText() !== typeParameters[0].getName())
+            return false;
+        if (!Node.isTypeLiteral(wrapperTypeNode))
+            return false;
+        if (wrapperTypeNode.getMembers().length !== 1)
+            return false;
+        const asProperty = wrapperTypeNode.getProperty('as');
+        if (!asProperty || !asProperty.hasQuestionToken())
+            return false;
+        return asProperty.getTypeNode()?.getText() === typeParameters[1].getName();
+    }
+    if (typeName === 'PropsWithHTMLElement') {
+        if (typeParameters.length !== 3)
+            return false;
+        if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
+            return false;
+        if (getTypeReferenceName(typeNode) !== 'Overwrite')
+            return false;
+        const [omittedDomPropsTypeNode, propsTypeNode] = typeNode.getTypeArguments();
+        if (!omittedDomPropsTypeNode || !propsTypeNode)
+            return false;
+        if (!Node.isTypeReference(omittedDomPropsTypeNode) &&
+            !Node.isExpressionWithTypeArguments(omittedDomPropsTypeNode)) {
+            return false;
+        }
+        if (getTypeReferenceName(omittedDomPropsTypeNode) !== 'Omit')
+            return false;
+        const [componentPropsTypeNode, omittedAdditionalPropsTypeNode] = omittedDomPropsTypeNode.getTypeArguments();
+        if (!componentPropsTypeNode || !omittedAdditionalPropsTypeNode)
+            return false;
+        if (getTypeReferenceName(componentPropsTypeNode) !== 'ComponentPropsWithoutRef')
+            return false;
+        if (!Node.isTypeReference(componentPropsTypeNode) && !Node.isExpressionWithTypeArguments(componentPropsTypeNode)) {
+            return false;
+        }
+        if (componentPropsTypeNode.getTypeArguments()[0]?.getText() !== typeParameters[1].getName())
+            return false;
+        if (omittedAdditionalPropsTypeNode.getText() !== typeParameters[2].getName())
+            return false;
+        return propsTypeNode.getText() === typeParameters[0].getName();
+    }
+    if (typeName === 'PolymorphicProps') {
+        if (typeParameters.length !== 3)
+            return false;
+        if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
+            return false;
+        if (getTypeReferenceName(typeNode) !== 'PropsWithAs')
+            return false;
+        const [propsTypeNode, elementTypeNode] = typeNode.getTypeArguments();
+        if (!propsTypeNode || !elementTypeNode)
+            return false;
+        if (!Node.isTypeReference(propsTypeNode) && !Node.isExpressionWithTypeArguments(propsTypeNode))
+            return false;
+        if (getTypeReferenceName(propsTypeNode) !== 'PropsWithHTMLElement')
+            return false;
+        const propsTypeArgs = propsTypeNode.getTypeArguments();
+        const propsWithAsTargetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
+        const propsWithHTMLElementTargetNode = Node.isTypeReference(propsTypeNode)
+            ? propsTypeNode.getTypeName()
+            : propsTypeNode.getExpression();
+        const hasExactPropsWithAsDeclaration = getTypeTargetDeclarations(propsWithAsTargetNode, true).some((declaration) => isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, 'PropsWithAs'));
+        const hasExactPropsWithHTMLElementDeclaration = getTypeTargetDeclarations(propsWithHTMLElementTargetNode, true).some((declaration) => isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, 'PropsWithHTMLElement'));
+        return (hasExactPropsWithAsDeclaration &&
+            hasExactPropsWithHTMLElementDeclaration &&
+            propsTypeArgs[0]?.getText() === typeParameters[0].getName() &&
+            propsTypeArgs[1]?.getText() === typeParameters[1].getName() &&
+            propsTypeArgs[2]?.getText() === typeParameters[2].getName() &&
+            elementTypeNode.getText() === typeParameters[1].getName());
+    }
+    return false;
+}
+export function unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, allowWorkspaceImportFallback) {
+    if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
+        return undefined;
+    const typeName = getTypeReferenceName(typeNode);
+    if (!typeName || !TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName))
+        return undefined;
+    const firstTypeArg = typeNode.getTypeArguments()[0];
+    if (!firstTypeArg)
+        return undefined;
+    const targetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
+    const declarations = getTypeTargetDeclarations(targetNode, allowWorkspaceImportFallback);
+    if (!declarations.some((declaration) => isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, typeName))) {
+        return undefined;
+    }
+    return firstTypeArg;
+}
+export function isRepoLocalSupportedPolymorphicChain(typeNode, seen = new Set(), allowWorkspaceImportFallback = false) {
+    if (seen.has(typeNode))
+        return false;
+    seen.add(typeNode);
+    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
+        return isRepoLocalSupportedPolymorphicChain(typeNode.getTypeNode(), seen, allowWorkspaceImportFallback);
+    }
+    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
+        const childTypes = typeNode.getTypeNodes();
+        return (childTypes.length > 0 &&
+            childTypes.every((child) => isRepoLocalSupportedPolymorphicChain(child, seen, allowWorkspaceImportFallback)));
+    }
+    if (Node.isTypeLiteral(typeNode) || Node.isInterfaceDeclaration(typeNode))
+        return true;
+    if (Node.isTypeReference(typeNode) || Node.isExpressionWithTypeArguments(typeNode)) {
+        const typeName = getTypeReferenceName(typeNode);
+        if (!typeName)
+            return false;
+        if (typeName === 'Omit' ||
+            typeName === 'Partial' ||
+            typeName === 'Readonly' ||
+            typeName === 'Required' ||
+            typeName === 'NonNullable' ||
+            typeName === 'MappedOmit') {
+            const wrappedType = getTypeReferenceArguments(typeNode)[0];
+            return wrappedType
+                ? isRepoLocalSupportedPolymorphicChain(wrappedType, seen, allowWorkspaceImportFallback)
+                : false;
+        }
+        if (!TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName)) {
+            const targetNode = getTypeReferenceTargetNode(typeNode);
+            if (!targetNode)
+                return false;
+            for (const declaration of getTypeTargetDeclarations(targetNode, allowWorkspaceImportFallback)) {
+                if (!declaration)
+                    continue;
+                if (Node.isInterfaceDeclaration(declaration)) {
+                    if (declaration
+                        .getHeritageClauses()
+                        .some((clause) => clause
+                        .getTypeNodes()
+                        .every((heritageTypeNode) => isRepoLocalSupportedPolymorphicChain(heritageTypeNode, seen, allowWorkspaceImportFallback)))) {
+                        return true;
+                    }
+                }
+                if (Node.isTypeAliasDeclaration(declaration)) {
+                    const aliasedTypeNode = declaration.getTypeNode();
+                    if (aliasedTypeNode &&
+                        isRepoLocalSupportedPolymorphicChain(aliasedTypeNode, seen, allowWorkspaceImportFallback)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        const wrappedTypeNode = unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, allowWorkspaceImportFallback);
+        return wrappedTypeNode
+            ? isRepoLocalSupportedPolymorphicChain(wrappedTypeNode, seen, allowWorkspaceImportFallback)
+            : false;
+    }
+    return false;
+}

package/dist/src/extract/framework-adapters/react/helpers/dom-attribute-surfaces.d.ts

@@ -0,0 +1,15 @@
+import { Node } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare const EXPANDABLE_DOM_ATTRIBUTE_TYPE_NAMES: Set<string>;
+export type ExpandableDomAttributeWrapperName = (typeof EXPANDABLE_DOM_ATTRIBUTE_TYPE_NAMES extends Set<infer T> ? T : never) & string;
+export type ExpandableDomAttributeWrapperContext = {
+    name: ExpandableDomAttributeWrapperName;
+    excludedProps: Set<string>;
+};
+export declare const DOM_ATTRIBUTE_PROP_SURFACES: Record<ExpandableDomAttributeWrapperName, RawPropDefinition[]>;
+export declare const DOM_ATTRIBUTE_WRAPPER_PARENTS: Partial<Record<ExpandableDomAttributeWrapperName, ExpandableDomAttributeWrapperName[]>>;
+export declare const DOM_ATTRIBUTE_WRAPPERS_WITH_SYNTHETIC_CHILDREN: Set<string>;
+export declare const JSX_PRIMITIVE_DOM_ATTRIBUTE_SURFACES: Partial<Record<string, ExpandableDomAttributeWrapperName>>;
+export declare function isExpandableDomAttributeWrapperName(typeName: string): typeName is ExpandableDomAttributeWrapperName;
+export declare function getDomAttributeSurface(name: ExpandableDomAttributeWrapperName, seen?: Set<string>): RawPropDefinition[];
+export declare function getBoundedImportedJsxDomSurface(tagNameNode: Node): ExpandableDomAttributeWrapperName | undefined;

package/dist/src/extract/framework-adapters/react/helpers/dom-attribute-surfaces.js

@@ -0,0 +1,231 @@
+import { Node } from 'ts-morph';
+export const EXPANDABLE_DOM_ATTRIBUTE_TYPE_NAMES = new Set([
+    'HTMLProps',
+    'HTMLAttributes',
+    'ImgHTMLAttributes',
+    'LiHTMLAttributes',
+    'AnchorHTMLAttributes',
+    'ButtonHTMLAttributes',
+    'InputHTMLAttributes',
+    'FieldsetHTMLAttributes',
+    'LabelHTMLAttributes',
+    'SelectHTMLAttributes',
+    'SVGAttributes',
+    'SVGProps',
+    'TextareaHTMLAttributes',
+    'TdHTMLAttributes',
+]);
+function createTextControlSurface(onChangeType, specificProps) {
+    return [
+        { name: 'autoComplete', type: 'string', required: false },
+        ...specificProps,
+        { name: 'disabled', type: 'boolean', required: false },
+        { name: 'name', type: 'string', required: false },
+        { name: 'onChange', type: onChangeType, required: false },
+        { name: 'placeholder', type: 'string', required: false },
+        { name: 'readOnly', type: 'boolean', required: false },
+        { name: 'required', type: 'boolean', required: false },
+        {
+            name: 'value',
+            type: 'string | number | readonly string[]',
+            required: false,
+        },
+    ];
+}
+export const DOM_ATTRIBUTE_PROP_SURFACES = {
+    HTMLProps: [],
+    HTMLAttributes: [
+        { name: 'className', type: 'string', required: false },
+        { name: 'hidden', type: 'boolean', required: false },
+        { name: 'id', type: 'string', required: false },
+        {
+            name: 'onClick',
+            type: 'MouseEventHandler<HTMLElement>',
+            required: false,
+        },
+        { name: 'style', type: 'CSSProperties', required: false },
+        { name: 'tabIndex', type: 'number', required: false },
+        { name: 'title', type: 'string', required: false },
+    ],
+    ImgHTMLAttributes: [
+        { name: 'alt', type: 'string', required: false },
+        { name: 'crossOrigin', type: 'string', required: false },
+        { name: 'height', type: 'number | string', required: false },
+        {
+            name: 'loading',
+            type: 'string',
+            required: false,
+            allowedValues: ['eager', 'lazy'],
+        },
+        { name: 'sizes', type: 'string', required: false },
+        { name: 'src', type: 'string', required: false },
+        { name: 'srcSet', type: 'string', required: false },
+        { name: 'width', type: 'number | string', required: false },
+    ],
+    LiHTMLAttributes: [],
+    AnchorHTMLAttributes: [
+        { name: 'download', type: 'boolean | string', required: false },
+        { name: 'href', type: 'string', required: false },
+        { name: 'hrefLang', type: 'string', required: false },
+        { name: 'referrerPolicy', type: 'string', required: false },
+        { name: 'rel', type: 'string', required: false },
+        {
+            name: 'target',
+            type: 'string',
+            required: false,
+            allowedValues: ['_blank', '_parent', '_self', '_top'],
+        },
+    ],
+    ButtonHTMLAttributes: [
+        { name: 'autoFocus', type: 'boolean', required: false },
+        { name: 'disabled', type: 'boolean', required: false },
+        { name: 'form', type: 'string', required: false },
+        { name: 'formAction', type: 'string', required: false },
+        { name: 'formMethod', type: 'string', required: false },
+        { name: 'formNoValidate', type: 'boolean', required: false },
+        { name: 'formTarget', type: 'string', required: false },
+        { name: 'name', type: 'string', required: false },
+        {
+            name: 'type',
+            type: 'string',
+            required: false,
+            allowedValues: ['button', 'reset', 'submit'],
+        },
+        {
+            name: 'value',
+            type: 'string | number | readonly string[]',
+            required: false,
+        },
+    ],
+    InputHTMLAttributes: createTextControlSurface('ChangeEventHandler<HTMLInputElement>', [
+        { name: 'checked', type: 'boolean', required: false },
+        { name: 'max', type: 'number | string', required: false },
+        { name: 'maxLength', type: 'number', required: false },
+        { name: 'min', type: 'number | string', required: false },
+        { name: 'minLength', type: 'number', required: false },
+        { name: 'type', type: 'string', required: false },
+    ]),
+    FieldsetHTMLAttributes: [
+        { name: 'disabled', type: 'boolean', required: false },
+        { name: 'form', type: 'string', required: false },
+        { name: 'name', type: 'string', required: false },
+    ],
+    LabelHTMLAttributes: [
+        { name: 'form', type: 'string', required: false },
+        { name: 'htmlFor', type: 'string', required: false },
+    ],
+    SelectHTMLAttributes: [
+        { name: 'autoComplete', type: 'string', required: false },
+        { name: 'disabled', type: 'boolean', required: false },
+        { name: 'form', type: 'string', required: false },
+        { name: 'multiple', type: 'boolean', required: false },
+        { name: 'name', type: 'string', required: false },
+        {
+            name: 'onChange',
+            type: 'ChangeEventHandler<HTMLSelectElement>',
+            required: false,
+        },
+        { name: 'required', type: 'boolean', required: false },
+        { name: 'size', type: 'number', required: false },
+        {
+            name: 'value',
+            type: 'string | number | readonly string[]',
+            required: false,
+        },
+    ],
+    SVGAttributes: [
+        {
+            name: 'focusable',
+            type: 'boolean | "auto"',
+            required: false,
+            allowedValues: ['auto'],
+        },
+        { name: 'height', type: 'number | string', required: false },
+        { name: 'viewBox', type: 'string', required: false },
+        { name: 'width', type: 'number | string', required: false },
+    ],
+    SVGProps: [],
+    TextareaHTMLAttributes: createTextControlSurface('ChangeEventHandler<HTMLTextAreaElement>', [
+        { name: 'cols', type: 'number', required: false },
+        { name: 'rows', type: 'number', required: false },
+        { name: 'wrap', type: 'string', required: false },
+    ]),
+    TdHTMLAttributes: [
+        {
+            name: 'align',
+            type: 'string',
+            required: false,
+            allowedValues: ['center', 'char', 'justify', 'left', 'right'],
+        },
+        { name: 'colSpan', type: 'number', required: false },
+        { name: 'headers', type: 'string', required: false },
+        { name: 'rowSpan', type: 'number', required: false },
+        { name: 'scope', type: 'string', required: false },
+    ],
+};
+export const DOM_ATTRIBUTE_WRAPPER_PARENTS = {
+    HTMLProps: ['HTMLAttributes'],
+    AnchorHTMLAttributes: ['HTMLAttributes'],
+    ButtonHTMLAttributes: ['HTMLAttributes'],
+    ImgHTMLAttributes: ['HTMLAttributes'],
+    InputHTMLAttributes: ['HTMLAttributes'],
+    FieldsetHTMLAttributes: ['HTMLAttributes'],
+    LabelHTMLAttributes: ['HTMLAttributes'],
+    LiHTMLAttributes: ['HTMLAttributes'],
+    SelectHTMLAttributes: ['HTMLAttributes'],
+    SVGAttributes: ['HTMLAttributes'],
+    SVGProps: ['SVGAttributes'],
+    TdHTMLAttributes: ['HTMLAttributes'],
+    TextareaHTMLAttributes: ['HTMLAttributes'],
+};
+export const DOM_ATTRIBUTE_WRAPPERS_WITH_SYNTHETIC_CHILDREN = new Set([
+    'LabelHTMLAttributes',
+]);
+export const JSX_PRIMITIVE_DOM_ATTRIBUTE_SURFACES = {
+    'Primitive.button': 'ButtonHTMLAttributes',
+    'Primitive.input': 'InputHTMLAttributes',
+    'Primitive.label': 'LabelHTMLAttributes',
+};
+export function isExpandableDomAttributeWrapperName(typeName) {
+    return EXPANDABLE_DOM_ATTRIBUTE_TYPE_NAMES.has(typeName);
+}
+export function getDomAttributeSurface(name, seen = new Set()) {
+    if (seen.has(name))
+        return [];
+    seen.add(name);
+    const propsByName = new Map();
+    for (const parentName of DOM_ATTRIBUTE_WRAPPER_PARENTS[name] ?? []) {
+        for (const prop of getDomAttributeSurface(parentName, seen)) {
+            propsByName.set(prop.name, prop);
+        }
+    }
+    for (const prop of DOM_ATTRIBUTE_PROP_SURFACES[name]) {
+        propsByName.set(prop.name, prop);
+    }
+    return [...propsByName.values()].map((prop) => ({
+        ...prop,
+        domAttribute: true,
+    }));
+}
+export function getBoundedImportedJsxDomSurface(tagNameNode) {
+    if (!Node.isIdentifier(tagNameNode))
+        return undefined;
+    const localName = tagNameNode.getText();
+    if (!/label/i.test(localName))
+        return undefined;
+    const declarations = tagNameNode.getSymbol()?.getDeclarations() ?? [];
+    for (const declaration of declarations) {
+        if (!Node.isImportSpecifier(declaration))
+            continue;
+        const importDeclaration = declaration.getImportDeclaration();
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        const importedName = declaration.getNameNode().getText();
+        const aliasName = declaration.getAliasNode()?.getText();
+        if (/label/i.test(moduleSpecifier) ||
+            /label/i.test(importedName) ||
+            (aliasName !== undefined && /label/i.test(aliasName))) {
+            return 'LabelHTMLAttributes';
+        }
+    }
+    return undefined;
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-binding-fallback-props.d.ts

@@ -0,0 +1,4 @@
+import { type ParameterDeclaration } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+import type { FunctionLike } from './resolve-component-function.js';
+export declare function extractDestructuredBindingFallbackProps(func: FunctionLike, param: ParameterDeclaration, existingPropNames: Set<string>, slotNames: Set<string>): RawPropDefinition[];

package/dist/src/extract/framework-adapters/react/helpers/extract-binding-fallback-props.js

@@ -0,0 +1,50 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getSourceLineMetadata } from '../../shared/helpers/get-node-source-lines.js';
+export function extractDestructuredBindingFallbackProps(func, param, existingPropNames, slotNames) {
+    const nameNode = param.getNameNode();
+    const bindingPatterns = [];
+    if (Node.isObjectBindingPattern(nameNode)) {
+        bindingPatterns.push(nameNode);
+    }
+    else if (Node.isIdentifier(nameNode)) {
+        const body = func.getBody();
+        const paramName = nameNode.getText();
+        if (body) {
+            for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+                const declarationName = declaration.getNameNode();
+                const initializer = declaration.getInitializer();
+                if (!Node.isObjectBindingPattern(declarationName))
+                    continue;
+                if (!initializer || !Node.isIdentifier(initializer) || initializer.getText() !== paramName)
+                    continue;
+                bindingPatterns.push(declarationName);
+            }
+        }
+    }
+    else {
+        return [];
+    }
+    const propsByName = new Map();
+    const paramType = param.getType();
+    for (const bindingPattern of bindingPatterns) {
+        for (const element of bindingPattern.getElements()) {
+            if (element.getDotDotDotToken())
+                continue;
+            const propName = element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText();
+            if (propName === 'children' || existingPropNames.has(propName) || slotNames.has(propName))
+                continue;
+            if (propsByName.has(propName))
+                continue;
+            const property = paramType.getProperty(propName);
+            const declaration = property?.getValueDeclaration() ?? property?.getDeclarations()[0];
+            const propertyType = property && declaration ? property.getTypeAtLocation(declaration).getText(declaration) : 'any';
+            propsByName.set(propName, {
+                name: propName,
+                type: propertyType === 'unknown' ? 'any' : propertyType,
+                required: property ? !property.isOptional() : false,
+                ...getSourceLineMetadata(declaration),
+            });
+        }
+    }
+    return [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-from-react-source-file.d.ts

@@ -0,0 +1,5 @@
+import { type SourceFile } from 'ts-morph';
+import type { ExtractionExclusion } from '../../../types/component.js';
+import { type RawComponentDefinitionInternal } from './extract-react-component-from-export.js';
+export declare function sourceFileUsesCreateContext(sourceFile: SourceFile): boolean;
+export declare function extractFromReactSourceFile(sourceFile: SourceFile, isNext: boolean, exclusions: ExtractionExclusion[]): RawComponentDefinitionInternal[];

package/dist/src/extract/framework-adapters/react/helpers/extract-from-react-source-file.js

@@ -0,0 +1,23 @@
+import { SyntaxKind } from 'ts-morph';
+import { getRenderableExports } from '../../shared/helpers/tsx-shared.js';
+import { extractReactComponentFromExport, } from './extract-react-component-from-export.js';
+export function sourceFileUsesCreateContext(sourceFile) {
+    return sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => {
+        const expr = call.getExpression();
+        const text = expr.getText();
+        return text === 'createContext' || text === 'React.createContext';
+    });
+}
+export function extractFromReactSourceFile(sourceFile, isNext, exclusions) {
+    const components = [];
+    const usesCreateContext = sourceFileUsesCreateContext(sourceFile);
+    for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
+        allowVariableDeclaration: true,
+        hookReason: 'React hook names are not renderable components',
+    })) {
+        const component = extractReactComponentFromExport(name, declarations, sourceFile, isNext, usesCreateContext);
+        if (component)
+            components.push(component);
+    }
+    return components;
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-react-allowed-components.d.ts

@@ -0,0 +1,2 @@
+import type { RawComponentDefinition } from '../../../types/component.js';
+export declare function resolveReactAllowedComponents(components: RawComponentDefinition[]): void;

package/dist/src/extract/framework-adapters/react/helpers/extract-react-allowed-components.js

@@ -0,0 +1,25 @@
+import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc, } from '../../../helpers/evidence/collect-allowed-component-names.js';
+import { buildComponentLookupMaps } from '../../shared/helpers/build-component-lookup-maps.js';
+export function resolveReactAllowedComponents(components) {
+    const { propsToComponent, componentNames } = buildComponentLookupMaps(components);
+    for (const c of components) {
+        for (const slot of c.slots) {
+            const found = new Set();
+            if (slot._rawTypeText) {
+                for (const n of extractAllowedComponentsFromTypeText(slot._rawTypeText, { propsToComponent, componentNames })) {
+                    found.add(n);
+                }
+            }
+            if (slot._rawJsdoc) {
+                for (const n of extractAllowedComponentsFromJsdoc(slot._rawJsdoc, componentNames)) {
+                    found.add(n);
+                }
+            }
+            delete slot._rawTypeText;
+            delete slot._rawJsdoc;
+            if (found.size > 0)
+                slot.allowedComponents = [...found].sort();
+        }
+        delete c._propsTypeName;
+    }
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-react-binding-defaults.d.ts

@@ -0,0 +1,6 @@
+import { Node } from 'ts-morph';
+import type { FunctionLike } from './resolve-component-function.js';
+export { isImplementationOnlyAliasProp, filterImplementationOnlyAliasProps } from './filter-impl-alias-props.js';
+export { extractDestructuredBindingFallbackProps } from './extract-binding-fallback-props.js';
+export declare function recordBindingPatternDefaults(nameNode: Node, defaults: Map<string, string>): void;
+export declare function extractDefaultValues(func: FunctionLike): Map<string, string>;

package/dist/src/extract/framework-adapters/react/helpers/extract-react-binding-defaults.js

@@ -0,0 +1,48 @@
+import { Node } from 'ts-morph';
+export { isImplementationOnlyAliasProp, filterImplementationOnlyAliasProps } from './filter-impl-alias-props.js';
+export { extractDestructuredBindingFallbackProps } from './extract-binding-fallback-props.js';
+export function recordBindingPatternDefaults(nameNode, defaults) {
+    if (!Node.isObjectBindingPattern(nameNode))
+        return;
+    for (const element of nameNode.getElements()) {
+        const initializer = element.getInitializer();
+        if (!initializer)
+            continue;
+        const propertyNameNode = element.getPropertyNameNode();
+        const propName = propertyNameNode?.getText().replace(/^['"]|['"]$/g, '') ?? element.getNameNode().getText();
+        const value = initializer.getText().replace(/^['"]|['"]$/g, '');
+        defaults.set(propName, value);
+    }
+}
+export function extractDefaultValues(func) {
+    const defaults = new Map();
+    const params = func.getParameters();
+    if (params.length === 0)
+        return defaults;
+    const firstParam = params[0];
+    const nameNode = firstParam.getNameNode();
+    if (Node.isObjectBindingPattern(nameNode)) {
+        recordBindingPatternDefaults(nameNode, defaults);
+        return defaults;
+    }
+    if (!Node.isIdentifier(nameNode))
+        return defaults;
+    const body = func.getBody();
+    if (!body || !Node.isBlock(body))
+        return defaults;
+    for (const statement of body.getStatements()) {
+        if (!Node.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.getDeclarationList().getDeclarations()) {
+            const declarationName = declaration.getNameNode();
+            const initializer = declaration.getInitializer();
+            if (!Node.isObjectBindingPattern(declarationName))
+                continue;
+            if (!initializer || !Node.isIdentifier(initializer) || initializer.getText() !== nameNode.getText())
+                continue;
+            recordBindingPatternDefaults(declarationName, defaults);
+            return defaults;
+        }
+    }
+    return defaults;
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-react-component-from-export.d.ts

@@ -0,0 +1,15 @@
+import { Node, type SourceFile } from 'ts-morph';
+import type { RawComponentDefinition, RawSlotDefinition } from '../../../types/component.js';
+import { type PropForwardingEdge } from './collect-prop-dataflow.js';
+import { type FunctionLike } from './resolve-component-function.js';
+export type RawSlotDefinitionInternal = RawSlotDefinition & {
+    _rawTypeText?: string;
+    _rawJsdoc?: string;
+};
+export type RawComponentDefinitionInternal = RawComponentDefinition & {
+    _componentIdentity?: string;
+    _propsTypeName?: string;
+    _propForwardingEdges?: PropForwardingEdge[];
+    _funcNode?: FunctionLike;
+};
+export declare function extractReactComponentFromExport(name: string, declarations: Node[], sourceFile: SourceFile, isNext: boolean, usesCreateContext: boolean): RawComponentDefinitionInternal | null;