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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-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[];