@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/extract-react-component-from-export.js

@@ -0,0 +1,106 @@
+import { Node } from 'ts-morph';
+import { shouldBeSlot } from '../../../helpers/evidence/detect-slot-from-prop.js';
+import { collectPropDataflow, getComponentIdentity } from './collect-prop-dataflow.js';
+import { resolveBestFunctionNode } from './resolve-component-function.js';
+import { collectRenderPropSlotNames, extractSlots } from './extract-react-slots.js';
+import { extractPropsFromType } from './extract-react-props-from-type.js';
+import { getSyntheticDomAttributeProps, hasSyntheticDomChildren, containsImportedOmitWrappedCustomProps, containsAnyPickType, } from './detect-dom-type-patterns.js';
+import { resolvePropsType } from './resolve-react-props-type.js';
+import { extractDefaultValues, filterImplementationOnlyAliasProps, extractDestructuredBindingFallbackProps, } from './extract-react-binding-defaults.js';
+import { inferPrimitiveDomPropsFromImplementation, hasImplementationChildrenHint } from './collect-react-impl-hints.js';
+import { extractPropTypes } from './extract-react-prop-types.js';
+const REACT_ELEMENT_GENERIC_TEST = /(?:React\.)?ReactElement\s*<\s*[A-Za-z_$][\w$.]*/;
+export function extractReactComponentFromExport(name, declarations, sourceFile, isNext, usesCreateContext) {
+    const funcNode = resolveBestFunctionNode(declarations);
+    if (!funcNode)
+        return null;
+    if (funcNode.getSourceFile().getFilePath() !== sourceFile.getFilePath())
+        return null;
+    const framework = isNext ? 'next' : 'react';
+    const source = sourceFile.getFilePath();
+    const base = {
+        name,
+        source,
+        sourcePath: source,
+        framework,
+        ...(usesCreateContext && { usesCreateContext: true }),
+    };
+    const params = funcNode.getParameters();
+    if (params.length === 0) {
+        return { ...base, props: [], slots: [] };
+    }
+    const resolvedPropsType = resolvePropsType(params[0]);
+    const firstParamType = resolvedPropsType.type;
+    const firstParamTypeNode = resolvedPropsType.typeNode;
+    const renderPropSlotNames = resolvedPropsType.suppressProps
+        ? new Set()
+        : collectRenderPropSlotNames(firstParamType);
+    const { props, hasChildren } = resolvedPropsType.suppressProps
+        ? { props: [], hasChildren: false }
+        : extractPropsFromType(firstParamType, renderPropSlotNames, firstParamTypeNode);
+    const hasMeaningfulExtractedProps = props.some((prop) => !prop.name.startsWith('__scope'));
+    const defaults = extractDefaultValues(funcNode);
+    const hasImplementationChildren = hasImplementationChildrenHint(funcNode, params[0]);
+    const slots = extractSlots(firstParamType, hasChildren ||
+        resolvedPropsType.hasWrappedChildren ||
+        hasSyntheticDomChildren(resolvedPropsType.typeNode) ||
+        hasImplementationChildren);
+    const syntheticDomProps = resolvedPropsType.suppressProps
+        ? []
+        : getSyntheticDomAttributeProps(resolvedPropsType.typeNode);
+    const implementationPrimitiveDomProps = !resolvedPropsType.suppressProps && !hasMeaningfulExtractedProps && syntheticDomProps.length === 0
+        ? inferPrimitiveDomPropsFromImplementation(funcNode, params[0])
+        : [];
+    const shouldTryBindingFallback = !resolvedPropsType.suppressProps &&
+        (containsImportedOmitWrappedCustomProps(firstParamTypeNode) ||
+            containsAnyPickType(firstParamTypeNode) ||
+            (!hasMeaningfulExtractedProps && Node.isObjectBindingPattern(params[0].getNameNode())));
+    const bindingFallbackProps = shouldTryBindingFallback
+        ? extractDestructuredBindingFallbackProps(funcNode, params[0], new Set(props.map((p) => p.name)), renderPropSlotNames)
+        : [];
+    const mergedPropsByName = new Map();
+    for (const prop of props)
+        mergedPropsByName.set(prop.name, prop);
+    for (const prop of syntheticDomProps)
+        if (!mergedPropsByName.has(prop.name))
+            mergedPropsByName.set(prop.name, prop);
+    for (const prop of implementationPrimitiveDomProps)
+        if (!mergedPropsByName.has(prop.name))
+            mergedPropsByName.set(prop.name, prop);
+    for (const prop of bindingFallbackProps)
+        if (!mergedPropsByName.has(prop.name))
+            mergedPropsByName.set(prop.name, prop);
+    const resolvedProps = [...mergedPropsByName.values()];
+    const noUsefulTypes = resolvedProps.length === 0 || resolvedProps.every((p) => p.type === 'any');
+    const finalProps = noUsefulTypes ? (extractPropTypes(sourceFile, name) ?? resolvedProps) : resolvedProps;
+    const propsWithDefaults = finalProps.map((p) => defaults.has(p.name) ? { ...p, required: false, defaultValue: defaults.get(p.name) } : p);
+    const propDataflow = collectPropDataflow(funcNode, params[0], new Set(propsWithDefaults.map((p) => p.name)));
+    const filteredProps = filterImplementationOnlyAliasProps(propsWithDefaults, funcNode).map((prop) => propDataflow.intrinsicDomProps.has(prop.name) ? { ...prop, domAttribute: true } : prop);
+    const existingSlotNames = new Set(slots.map((s) => s.name));
+    const expandedSlots = [];
+    const propsAfterSlotExpansion = filteredProps.filter((prop) => {
+        if (existingSlotNames.has(prop.name))
+            return true;
+        const isElementSlot = REACT_ELEMENT_GENERIC_TEST.test(prop.type);
+        if (shouldBeSlot(prop.name, prop.type) || isElementSlot) {
+            expandedSlots.push({
+                name: prop.name,
+                isDefault: false,
+                ...(isElementSlot ? { _rawTypeText: prop.type } : {}),
+            });
+            return false;
+        }
+        return true;
+    });
+    const propsTypeName = firstParamTypeNode?.getText?.().trim();
+    const propsTypeNameCapture = propsTypeName && /^[A-Za-z_$][\w$]*$/.test(propsTypeName) ? propsTypeName : undefined;
+    return {
+        ...base,
+        props: propsAfterSlotExpansion,
+        slots: [...slots, ...expandedSlots],
+        _componentIdentity: getComponentIdentity(funcNode),
+        _funcNode: funcNode,
+        ...(propsTypeNameCapture ? { _propsTypeName: propsTypeNameCapture } : {}),
+        ...(propDataflow.componentEdges.length > 0 ? { _propForwardingEdges: propDataflow.componentEdges } : {}),
+    };
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-react-prop-types.d.ts

@@ -0,0 +1,3 @@
+import { type SourceFile } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractPropTypes(sourceFile: SourceFile, componentName: string): RawPropDefinition[] | undefined;

package/dist/src/extract/framework-adapters/react/helpers/extract-react-prop-types.js

@@ -0,0 +1,64 @@
+import { Node } from 'ts-morph';
+const PROP_TYPES_MAP = {
+    string: 'string',
+    number: 'number',
+    bool: 'boolean',
+    func: 'function',
+    node: 'ReactNode',
+    element: 'ReactElement',
+    any: 'any',
+    array: 'any[]',
+    object: 'object',
+    symbol: 'symbol',
+};
+export function extractPropTypes(sourceFile, componentName) {
+    const props = [];
+    for (const statement of sourceFile.getStatements()) {
+        if (!Node.isExpressionStatement(statement))
+            continue;
+        const expr = statement.getExpression();
+        if (!Node.isBinaryExpression(expr))
+            continue;
+        const left = expr.getLeft().getText();
+        if (left !== `${componentName}.propTypes`)
+            continue;
+        const right = expr.getRight();
+        if (!Node.isObjectLiteralExpression(right))
+            continue;
+        for (const property of right.getProperties()) {
+            if (!Node.isPropertyAssignment(property))
+                continue;
+            const propName = property.getName();
+            const initText = property.getInitializer()?.getText() ?? '';
+            let type = 'any';
+            let required = false;
+            let allowedValues;
+            if (initText.includes('.isRequired'))
+                required = true;
+            const oneOfMatch = initText.match(/PropTypes\.oneOf\(\[([^\]]+)\]\)/);
+            if (oneOfMatch) {
+                allowedValues = oneOfMatch[1]
+                    .split(',')
+                    .map((v) => v.trim().replace(/^['"]|['"]$/g, ''))
+                    .filter(Boolean)
+                    .sort();
+            }
+            for (const [ptKey, tsType] of Object.entries(PROP_TYPES_MAP)) {
+                if (initText.includes(`PropTypes.${ptKey}`)) {
+                    type = tsType;
+                    break;
+                }
+            }
+            props.push({
+                name: propName,
+                type,
+                required,
+                ...(allowedValues && { allowedValues }),
+                sourceStartLine: property.getStartLineNumber(),
+                sourceEndLine: property.getEndLineNumber(),
+            });
+        }
+        return props.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    return undefined;
+}

package/dist/src/extract/framework-adapters/react/helpers/extract-react-props-from-type.d.ts

@@ -0,0 +1,15 @@
+import { Node, type Type } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractPropsFromTypeSymbols(type: Type, slotNames: Set<string>, suppressNeverChildrenSlot?: boolean): {
+    props: RawPropDefinition[];
+    hasChildren: boolean;
+};
+export declare function extractPropsFromTypeNode(typeNode: Node, slotNames: Set<string>, seen?: Set<Node<import("ts-morph").ts.Node>>, excludedProps?: Set<string>, allowImportedOmitWorkspaceFallback?: boolean, suppressNeverChildrenSlot?: boolean): {
+    props: RawPropDefinition[];
+    hasChildren: boolean;
+};
+export declare function extractPickedPropsFromTypeNode(typeNode: Node, slotNames: Set<string>, excludedProps?: Set<string>): RawPropDefinition[];
+export declare function extractPropsFromType(type: Type, slotNames: Set<string>, typeNode?: Node): {
+    props: RawPropDefinition[];
+    hasChildren: boolean;
+};

package/dist/src/extract/framework-adapters/react/helpers/extract-react-props-from-type.js

@@ -0,0 +1,318 @@
+import { Node } from 'ts-morph';
+import { extractAllowedValues, getTypeReferenceName, getTypeTargetDeclarations, } from '../../shared/helpers/tsx-shared.js';
+import { getSourceLineMetadata } from '../../shared/helpers/get-node-source-lines.js';
+import { collectExpandableDomAttributeWrapperContexts, isPureExpandableDomAttributeWrapperType, shouldMergeDomSyntaxExtraction, containsImportedOmitWrappedCustomProps, getStringLiteralTypeValues, getSyntheticDomAttributeProps, } from './detect-dom-type-patterns.js';
+import { TRANSPARENT_POLYMORPHIC_TYPE_NAMES, isRepoLocalSupportedPolymorphicChain, unwrapRepoLocalTransparentPolymorphicWrapper, } from './detect-react-polymorphic.js';
+import { isExpandableDomAttributeWrapperName } from './dom-attribute-surfaces.js';
+function getTypeReferenceTargetNode(typeNode) {
+    if (Node.isTypeReference(typeNode))
+        return typeNode.getTypeName();
+    if (Node.isExpressionWithTypeArguments(typeNode))
+        return typeNode.getExpression();
+    return undefined;
+}
+function getTypeReferenceArguments(typeNode) {
+    if (Node.isTypeReference(typeNode) || Node.isExpressionWithTypeArguments(typeNode)) {
+        return typeNode.getTypeArguments();
+    }
+    return [];
+}
+function filterExcludedSyntaxProps(extraction, excludedProps) {
+    if (excludedProps.size === 0)
+        return extraction;
+    return {
+        ...extraction,
+        props: extraction.props.filter((prop) => !excludedProps.has(prop.name)),
+    };
+}
+export function extractPropsFromTypeSymbols(type, slotNames, suppressNeverChildrenSlot = false) {
+    const props = [];
+    let hasChildren = false;
+    for (const property of type.getProperties()) {
+        const name = property.getName();
+        if (name === 'children') {
+            if (suppressNeverChildrenSlot) {
+                const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
+                if (declaration && property.getTypeAtLocation(declaration).isNever())
+                    continue;
+            }
+            hasChildren = true;
+            continue;
+        }
+        if (slotNames.has(name))
+            continue;
+        const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
+        if (!declaration)
+            continue;
+        const propType = property.getTypeAtLocation(declaration);
+        const declarationTypeText = 'getTypeNode' in declaration && typeof declaration.getTypeNode === 'function'
+            ? declaration.getTypeNode()?.getText()
+            : undefined;
+        const typeText = propType.isAny() && declarationTypeText ? declarationTypeText : propType.getText(declaration);
+        const required = !property.isOptional();
+        const allowedValues = extractAllowedValues(propType);
+        props.push({
+            name,
+            type: typeText,
+            required,
+            ...(allowedValues && { allowedValues }),
+            ...getSourceLineMetadata(declaration),
+        });
+    }
+    return {
+        props: props.sort((a, b) => a.name.localeCompare(b.name)),
+        hasChildren,
+    };
+}
+function extractPropsFromInterfaceDeclaration(declaration, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot) {
+    const hasExpandableDomHeritage = declaration
+        .getHeritageClauses()
+        .some((clause) => clause.getTypeNodes().some((typeNode) => collectExpandableDomAttributeWrapperContexts(typeNode).length > 0));
+    const symbolType = hasExpandableDomHeritage
+        ? declaration
+            .getType()
+            .getProperties()
+            .filter((symbol) => {
+            const decl = symbol.getValueDeclaration() ?? symbol.getDeclarations()[0];
+            return decl?.getParent() === declaration;
+        })
+            .reduce((acc, symbol) => {
+            const decl = symbol.getValueDeclaration() ?? symbol.getDeclarations()[0];
+            if (!decl)
+                return acc;
+            const propType = symbol.getTypeAtLocation(decl);
+            const typeText = propType.isAny()
+                ? (('getTypeNode' in decl &&
+                    typeof decl.getTypeNode === 'function'
+                    ? decl.getTypeNode()?.getText()
+                    : undefined) ?? propType.getText(decl))
+                : propType.getText(decl);
+            const name = symbol.getName();
+            if (name === 'children') {
+                if (suppressNeverChildrenSlot && propType.isNever())
+                    return acc;
+                acc.hasChildren = true;
+                return acc;
+            }
+            if (slotNames.has(name))
+                return acc;
+            const required = !symbol.isOptional();
+            const allowedValues = extractAllowedValues(propType);
+            acc.props.push({
+                name,
+                type: typeText,
+                required,
+                ...(allowedValues && { allowedValues }),
+                ...getSourceLineMetadata(decl),
+            });
+            return acc;
+        }, { props: [], hasChildren: false })
+        : extractPropsFromTypeSymbols(declaration.getType(), slotNames, suppressNeverChildrenSlot);
+    const ownProps = filterExcludedSyntaxProps(symbolType, excludedProps);
+    const inheritedProps = declaration
+        .getHeritageClauses()
+        .flatMap((clause) => clause
+        .getTypeNodes()
+        .flatMap((heritageTypeNode) => extractPropsFromTypeNode(heritageTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot).props));
+    return {
+        props: [...ownProps.props, ...inheritedProps].sort((a, b) => a.name.localeCompare(b.name)),
+        hasChildren: ownProps.hasChildren,
+    };
+}
+function getMappedOmitEquivalentArgs(typeNode) {
+    if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
+        return undefined;
+    const [wrappedType, omittedProps] = typeNode.getTypeArguments();
+    if (!wrappedType || !omittedProps)
+        return undefined;
+    const targetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
+    for (const declaration of getTypeTargetDeclarations(targetNode, true)) {
+        if (!Node.isTypeAliasDeclaration(declaration))
+            continue;
+        if (declaration.getTypeParameters().length !== 2)
+            continue;
+        const mappedTypeNode = declaration.getTypeNode();
+        const [sourceTypeParameter, excludedKeysParameter] = declaration.getTypeParameters();
+        const sourceTypeParameterName = sourceTypeParameter.getName();
+        const excludedKeysParameterName = excludedKeysParameter.getName();
+        if (!mappedTypeNode)
+            continue;
+        if (Node.isTypeReference(mappedTypeNode) || Node.isExpressionWithTypeArguments(mappedTypeNode)) {
+            if (getTypeReferenceName(mappedTypeNode) !== 'Omit')
+                continue;
+            const [innerWrappedType, innerOmittedProps] = mappedTypeNode.getTypeArguments();
+            if (!innerWrappedType || !innerOmittedProps)
+                continue;
+            if (innerWrappedType.getText() !== sourceTypeParameterName)
+                continue;
+            if (innerOmittedProps.getText() !== excludedKeysParameterName)
+                continue;
+            return { wrappedType, omittedProps };
+        }
+        if (!Node.isMappedTypeNode(mappedTypeNode))
+            continue;
+        const iterationParameter = mappedTypeNode.getTypeParameter();
+        const iterationParameterName = iterationParameter.getName();
+        if (iterationParameter.getConstraint()?.getText() !== `keyof ${sourceTypeParameterName}`)
+            continue;
+        if (mappedTypeNode.getNameTypeNode()?.getText() !==
+            `${iterationParameterName} extends ${excludedKeysParameterName} ? never : ${iterationParameterName}`) {
+            continue;
+        }
+        if (mappedTypeNode.getTypeNode()?.getText() !== `${sourceTypeParameterName}[${iterationParameterName}]`)
+            continue;
+        return { wrappedType, omittedProps };
+    }
+    return undefined;
+}
+export function extractPropsFromTypeNode(typeNode, slotNames, seen = new Set(), excludedProps = new Set(), allowImportedOmitWorkspaceFallback = false, suppressNeverChildrenSlot = false) {
+    if (seen.has(typeNode))
+        return { props: [], hasChildren: false };
+    seen.add(typeNode);
+    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
+        return extractPropsFromTypeNode(typeNode.getTypeNode(), slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
+    }
+    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
+        const propsByName = new Map();
+        let hasChildren = false;
+        for (const childTypeNode of typeNode.getTypeNodes()) {
+            const extracted = extractPropsFromTypeNode(childTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
+            hasChildren ||= extracted.hasChildren;
+            for (const prop of extracted.props) {
+                propsByName.set(prop.name, prop);
+            }
+        }
+        return { props: [...propsByName.values()], hasChildren };
+    }
+    if (Node.isTypeLiteral(typeNode)) {
+        return filterExcludedSyntaxProps(extractPropsFromTypeSymbols(typeNode.getType(), slotNames, suppressNeverChildrenSlot), excludedProps);
+    }
+    if (Node.isInterfaceDeclaration(typeNode)) {
+        return extractPropsFromInterfaceDeclaration(typeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
+    }
+    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
+    if (typeReferenceTarget) {
+        const typeName = getTypeReferenceName(typeNode);
+        if (!typeName)
+            return { props: [], hasChildren: false };
+        const typeArguments = getTypeReferenceArguments(typeNode);
+        if (typeName === 'PropsWithChildren') {
+            const wrappedType = typeArguments[0];
+            if (!wrappedType)
+                return { props: [], hasChildren: true };
+            const extracted = extractPropsFromTypeNode(wrappedType, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
+            return { props: extracted.props, hasChildren: true };
+        }
+        if (isExpandableDomAttributeWrapperName(typeName) || typeName === 'Pick') {
+            return typeName === 'Pick'
+                ? {
+                    props: extractPickedPropsFromTypeNode(typeNode, slotNames, excludedProps),
+                    hasChildren: false,
+                }
+                : { props: [], hasChildren: false };
+        }
+        if (typeName === 'Omit' ||
+            typeName === 'Partial' ||
+            typeName === 'Readonly' ||
+            typeName === 'Required' ||
+            typeName === 'NonNullable') {
+            const wrappedType = typeArguments[0];
+            if (!wrappedType)
+                return { props: [], hasChildren: false };
+            const nextExcludedProps = new Set(excludedProps);
+            if (typeName === 'Omit') {
+                const omittedProps = typeArguments[1];
+                if (omittedProps) {
+                    for (const value of getStringLiteralTypeValues(omittedProps)) {
+                        nextExcludedProps.add(value);
+                    }
+                }
+            }
+            return extractPropsFromTypeNode(wrappedType, slotNames, seen, nextExcludedProps, allowImportedOmitWorkspaceFallback || typeName === 'Omit', suppressNeverChildrenSlot);
+        }
+        const mappedOmitArgs = allowImportedOmitWorkspaceFallback ? getMappedOmitEquivalentArgs(typeNode) : undefined;
+        if (mappedOmitArgs) {
+            const nextExcludedProps = new Set(excludedProps);
+            for (const value of getStringLiteralTypeValues(mappedOmitArgs.omittedProps)) {
+                nextExcludedProps.add(value);
+            }
+            return extractPropsFromTypeNode(mappedOmitArgs.wrappedType, slotNames, seen, nextExcludedProps, true, suppressNeverChildrenSlot);
+        }
+        const wrappedTypeNode = unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, allowImportedOmitWorkspaceFallback) ??
+            (!allowImportedOmitWorkspaceFallback ? unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, true) : undefined);
+        if (wrappedTypeNode) {
+            return extractPropsFromTypeNode(wrappedTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, true);
+        }
+        if (TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName))
+            return { props: [], hasChildren: false };
+        for (const declaration of getTypeTargetDeclarations(typeReferenceTarget, allowImportedOmitWorkspaceFallback)) {
+            if (!declaration)
+                continue;
+            if (Node.isInterfaceDeclaration(declaration)) {
+                return extractPropsFromInterfaceDeclaration(declaration, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
+            }
+            if (Node.isTypeAliasDeclaration(declaration)) {
+                const aliasedTypeNode = declaration.getTypeNode();
+                if (!aliasedTypeNode)
+                    continue;
+                return extractPropsFromTypeNode(aliasedTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
+            }
+        }
+    }
+    return { props: [], hasChildren: false };
+}
+export function extractPickedPropsFromTypeNode(typeNode, slotNames, excludedProps = new Set()) {
+    if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
+        return [];
+    const [sourceTypeNode, pickedKeysNode] = typeNode.getTypeArguments();
+    if (!sourceTypeNode || !pickedKeysNode)
+        return [];
+    const sourcePropsByName = new Map();
+    for (const prop of getSyntheticDomAttributeProps(sourceTypeNode)) {
+        sourcePropsByName.set(prop.name, prop);
+    }
+    for (const prop of extractPropsFromTypeNode(sourceTypeNode, slotNames, undefined, excludedProps).props) {
+        if (!sourcePropsByName.has(prop.name))
+            sourcePropsByName.set(prop.name, prop);
+    }
+    const pickedKeys = getStringLiteralTypeValues(pickedKeysNode);
+    const props = [];
+    for (const name of pickedKeys) {
+        if (slotNames.has(name))
+            continue;
+        if (excludedProps.has(name))
+            continue;
+        const pickedProp = sourcePropsByName.get(name);
+        if (pickedProp)
+            props.push(pickedProp);
+    }
+    return props.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function extractPropsFromType(type, slotNames, typeNode) {
+    const supportsRepoLocalPolymorphicAlias = typeNode !== undefined && isRepoLocalSupportedPolymorphicChain(typeNode, new Set(), true);
+    const suppressNeverChildrenSlot = supportsRepoLocalPolymorphicAlias;
+    const isPureDomWrapper = typeNode !== undefined && isPureExpandableDomAttributeWrapperType(typeNode);
+    const symbolExtraction = supportsRepoLocalPolymorphicAlias || isPureDomWrapper
+        ? { props: [], hasChildren: false }
+        : extractPropsFromTypeSymbols(type, slotNames, suppressNeverChildrenSlot);
+    const syntaxExtraction = typeNode &&
+        (symbolExtraction.props.length === 0 ||
+            shouldMergeDomSyntaxExtraction(typeNode) ||
+            containsImportedOmitWrappedCustomProps(typeNode))
+        ? extractPropsFromTypeNode(typeNode, slotNames, undefined, new Set(), false, suppressNeverChildrenSlot)
+        : { props: [], hasChildren: false };
+    const propsByName = new Map();
+    const useSyntaxOnly = typeNode !== undefined && shouldMergeDomSyntaxExtraction(typeNode);
+    if (!useSyntaxOnly) {
+        for (const prop of symbolExtraction.props) {
+            propsByName.set(prop.name, prop);
+        }
+    }
+    for (const prop of syntaxExtraction.props) {
+        propsByName.set(prop.name, prop);
+    }
+    return {
+        props: [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name)),
+        hasChildren: symbolExtraction.hasChildren || syntaxExtraction.hasChildren,
+    };
+}

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

@@ -0,0 +1,6 @@
+import { type Type, type Symbol as MorphSymbol } from 'ts-morph';
+import type { RawSlotDefinition } from '../../../types/component.js';
+export declare function isRenderPropType(type: Type): boolean;
+export declare function getRenderPropType(property: MorphSymbol): Type | undefined;
+export declare function collectRenderPropSlotNames(type: Type): Set<string>;
+export declare function extractSlots(type: Type, hasChildren: boolean): RawSlotDefinition[];

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

@@ -0,0 +1,44 @@
+export function isRenderPropType(type) {
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length === 0)
+        return false;
+    const returnType = callSignatures[0].getReturnType();
+    const returnText = returnType.getText();
+    return /ReactNode|ReactElement|JSX\.Element|Element/.test(returnText);
+}
+export function getRenderPropType(property) {
+    if (!property.getName().startsWith('render'))
+        return undefined;
+    const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
+    if (!declaration)
+        return undefined;
+    const propType = property.getTypeAtLocation(declaration);
+    return isRenderPropType(propType) ? propType : undefined;
+}
+export function collectRenderPropSlotNames(type) {
+    const names = new Set();
+    for (const property of type.getProperties()) {
+        if (getRenderPropType(property))
+            names.add(property.getName());
+    }
+    return names;
+}
+export function extractSlots(type, hasChildren) {
+    const slots = [];
+    if (hasChildren) {
+        slots.push({ name: 'children', isDefault: true });
+    }
+    for (const property of type.getProperties()) {
+        const name = property.getName();
+        if (name === 'children')
+            continue;
+        if (!getRenderPropType(property))
+            continue;
+        const slotName = name.replace(/^render/, '');
+        slots.push({
+            name: slotName.charAt(0).toLowerCase() + slotName.slice(1),
+            isDefault: false,
+        });
+    }
+    return slots.sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/extract/framework-adapters/react/helpers/filter-impl-alias-props.d.ts

@@ -0,0 +1,4 @@
+import type { RawPropDefinition } from '../../../types/component.js';
+import type { FunctionLike } from './resolve-component-function.js';
+export declare function isImplementationOnlyAliasProp(func: FunctionLike, propName: string): boolean;
+export declare function filterImplementationOnlyAliasProps(props: RawPropDefinition[], func: FunctionLike): RawPropDefinition[];

package/dist/src/extract/framework-adapters/react/helpers/filter-impl-alias-props.js

@@ -0,0 +1,52 @@
+import { Node } from 'ts-morph';
+export function isImplementationOnlyAliasProp(func, propName) {
+    if (!propName.startsWith('_'))
+        return false;
+    const allowedJsxAttributes = new Set([
+        'id',
+        'htmlFor',
+        'aria-activedescendant',
+        'aria-controls',
+        'aria-describedby',
+        'aria-labelledby',
+        'aria-owns',
+    ]);
+    let sawRuntimeUsage = false;
+    for (const node of func.getDescendants()) {
+        if (!Node.isIdentifier(node) || node.getText() !== propName)
+            continue;
+        const bindingElement = node.getFirstAncestor((ancestor) => Node.isBindingElement(ancestor));
+        if (bindingElement?.getNameNode() === node)
+            continue;
+        const jsxAttribute = node.getFirstAncestor((ancestor) => Node.isJsxAttribute(ancestor));
+        if (jsxAttribute) {
+            const attributeName = jsxAttribute.getNameNode().getText();
+            if (allowedJsxAttributes.has(attributeName)) {
+                sawRuntimeUsage = true;
+                continue;
+            }
+            return false;
+        }
+        const propertyAssignment = node.getFirstAncestor((ancestor) => Node.isPropertyAssignment(ancestor));
+        if (propertyAssignment) {
+            const propertyName = propertyAssignment.getName();
+            if (propertyName === propName) {
+                sawRuntimeUsage = true;
+                continue;
+            }
+            return false;
+        }
+        return false;
+    }
+    return sawRuntimeUsage;
+}
+export function filterImplementationOnlyAliasProps(props, func) {
+    const publicPropNames = new Set(props.filter((prop) => !prop.name.startsWith('_')).map((prop) => prop.name));
+    return props.filter((prop) => {
+        if (/^__scope[A-Z]/.test(prop.name))
+            return false;
+        if (prop.name.startsWith('_') && publicPropNames.has(prop.name.slice(1)))
+            return false;
+        return !isImplementationOnlyAliasProp(func, prop.name);
+    });
+}

package/dist/src/extract/framework-adapters/react/helpers/infer-primitive-dom-props.d.ts

@@ -0,0 +1,6 @@
+import { Node, type ParameterDeclaration } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+import type { FunctionLike } from './resolve-component-function.js';
+export declare function collectRestBindingNames(nameNode: Node): Set<string>;
+export declare function isComponentSpreadAttribute(attribute: Node, bindingNames: Set<string>): boolean;
+export declare function inferPrimitiveDomPropsFromImplementation(funcNode: FunctionLike, propsParam: ParameterDeclaration): RawPropDefinition[];