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

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

@@ -0,0 +1,220 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getJsxTagNameNode, getNodeDefinitions, getValueTargetDeclarations, isIntrinsicJsxElement, } from '../../shared/helpers/tsx-shared.js';
+import { resolveFunctionNode } from './resolve-component-function.js';
+function getDeclarationIdentity(node) {
+    if (Node.isIdentifier(node)) {
+        const parent = node.getParent();
+        if ((Node.isVariableDeclaration(parent) || Node.isBindingElement(parent) || Node.isParameterDeclaration(parent)) &&
+            parent.getNameNode() === node) {
+            return parent;
+        }
+    }
+    return getNodeDefinitions(node)[0]?.getDeclarationNode() ?? node;
+}
+export function getComponentIdentity(func) {
+    return `${func.getSourceFile().getFilePath()}:${func.getStart()}`;
+}
+function resolveForwardedComponentIdentity(tagNameNode) {
+    if (!Node.isIdentifier(tagNameNode))
+        return undefined;
+    for (const declaration of getValueTargetDeclarations(tagNameNode)) {
+        const func = resolveFunctionNode(declaration);
+        if (func)
+            return getComponentIdentity(func);
+    }
+    return undefined;
+}
+/**
+ * Declarations that are rebound somewhere in the body, so their initializer no
+ * longer describes the value that reaches JSX.
+ */
+function collectReboundDeclarations(body) {
+    const rebound = new Set();
+    const recordTarget = (target) => {
+        if (Node.isIdentifier(target)) {
+            rebound.add(getDeclarationIdentity(target));
+            return;
+        }
+        if ((Node.isPropertyAccessExpression(target) || Node.isElementAccessExpression(target)) &&
+            Node.isIdentifier(target.getExpression())) {
+            rebound.add(getDeclarationIdentity(target.getExpression()));
+        }
+    };
+    for (const assignment of body?.getDescendantsOfKind(SyntaxKind.BinaryExpression) ?? []) {
+        // Covers `=` and every compound form (`+=`, `??=`, `>>>=`, ...).
+        const operator = assignment.getOperatorToken().getKind();
+        if (operator < SyntaxKind.FirstAssignment || operator > SyntaxKind.LastAssignment)
+            continue;
+        recordTarget(assignment.getLeft());
+    }
+    // Only `++`/`--` rebind the operand. Reading a prop through `!`, `-`, `+`, or
+    // `~` leaves the alias intact, so those operators must not invalidate it.
+    for (const update of body?.getDescendantsOfKind(SyntaxKind.PrefixUnaryExpression) ?? []) {
+        const operator = update.getOperatorToken();
+        if (operator !== SyntaxKind.PlusPlusToken && operator !== SyntaxKind.MinusMinusToken)
+            continue;
+        recordTarget(update.getOperand());
+    }
+    for (const update of body?.getDescendantsOfKind(SyntaxKind.PostfixUnaryExpression) ?? []) {
+        recordTarget(update.getOperand());
+    }
+    return rebound;
+}
+/** Trace only statically resolvable, component-local prop dataflow into JSX. */
+export function collectPropDataflow(func, param, availablePropNames) {
+    const valueAliases = new Map();
+    const objectAliases = new Map();
+    const fullPropsShape = new Map([...availablePropNames].map((name) => [name, name]));
+    const belongsToComponentFunction = (node) => node.getFirstAncestor((ancestor) => Node.isFunctionDeclaration(ancestor) || Node.isArrowFunction(ancestor) || Node.isFunctionExpression(ancestor)) === func;
+    const resolveValue = (expression) => {
+        if (!expression)
+            return undefined;
+        if (Node.isParenthesizedExpression(expression))
+            return resolveValue(expression.getExpression());
+        if (Node.isIdentifier(expression))
+            return valueAliases.get(getDeclarationIdentity(expression));
+        if (Node.isPropertyAccessExpression(expression)) {
+            const object = expression.getExpression();
+            return Node.isIdentifier(object)
+                ? objectAliases.get(getDeclarationIdentity(object))?.get(expression.getName())
+                : undefined;
+        }
+        if (Node.isElementAccessExpression(expression)) {
+            const argument = expression.getArgumentExpression();
+            if (!argument || (!Node.isStringLiteral(argument) && !Node.isNoSubstitutionTemplateLiteral(argument))) {
+                return undefined;
+            }
+            const object = expression.getExpression();
+            return Node.isIdentifier(object)
+                ? objectAliases.get(getDeclarationIdentity(object))?.get(argument.getLiteralText())
+                : undefined;
+        }
+        return undefined;
+    };
+    const resolveObject = (expression) => {
+        if (!expression)
+            return undefined;
+        if (Node.isParenthesizedExpression(expression))
+            return resolveObject(expression.getExpression());
+        if (Node.isIdentifier(expression))
+            return objectAliases.get(getDeclarationIdentity(expression));
+        if (!Node.isObjectLiteralExpression(expression))
+            return undefined;
+        const shape = new Map();
+        for (const property of expression.getProperties()) {
+            if (Node.isSpreadAssignment(property)) {
+                const spreadShape = resolveObject(property.getExpression());
+                for (const [targetProp, sourceProp] of spreadShape ?? [])
+                    shape.set(targetProp, sourceProp);
+            }
+            else if (Node.isShorthandPropertyAssignment(property)) {
+                const sourceProp = resolveValue(property.getNameNode());
+                if (sourceProp)
+                    shape.set(property.getName(), sourceProp);
+            }
+            else if (Node.isPropertyAssignment(property)) {
+                const propertyNameNode = property.getNameNode();
+                if (!Node.isIdentifier(propertyNameNode) && !Node.isStringLiteral(propertyNameNode))
+                    continue;
+                const sourceProp = resolveValue(property.getInitializer());
+                if (sourceProp)
+                    shape.set(property.getName(), sourceProp);
+            }
+        }
+        return shape;
+    };
+    const addBindings = (pattern, sourceShape) => {
+        const omittedProps = new Set(pattern
+            .getElements()
+            .filter((element) => !element.getDotDotDotToken())
+            .map((element) => element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText()));
+        for (const element of pattern.getElements()) {
+            const localName = element.getNameNode();
+            if (!Node.isIdentifier(localName))
+                continue;
+            if (element.getDotDotDotToken()) {
+                objectAliases.set(getDeclarationIdentity(localName), new Map([...sourceShape].filter(([targetProp]) => !omittedProps.has(targetProp))));
+                continue;
+            }
+            const targetProp = element.getPropertyNameNode()?.getText() ?? localName.getText();
+            const sourceProp = sourceShape.get(targetProp);
+            if (sourceProp)
+                valueAliases.set(getDeclarationIdentity(localName), sourceProp);
+        }
+    };
+    const paramNameNode = param.getNameNode();
+    if (Node.isIdentifier(paramNameNode))
+        objectAliases.set(getDeclarationIdentity(paramNameNode), fullPropsShape);
+    else if (Node.isObjectBindingPattern(paramNameNode))
+        addBindings(paramNameNode, fullPropsShape);
+    const body = func.getBody();
+    const reboundDeclarations = collectReboundDeclarations(body);
+    for (const declaration of reboundDeclarations) {
+        valueAliases.delete(declaration);
+        objectAliases.delete(declaration);
+    }
+    for (const declaration of body?.getDescendantsOfKind(SyntaxKind.VariableDeclaration) ?? []) {
+        if (!belongsToComponentFunction(declaration))
+            continue;
+        const initializer = declaration.getInitializer();
+        const declarationName = declaration.getNameNode();
+        if (Node.isIdentifier(declarationName)) {
+            const aliasDeclaration = getDeclarationIdentity(declarationName);
+            if (reboundDeclarations.has(aliasDeclaration))
+                continue;
+            const sourceProp = resolveValue(initializer);
+            if (sourceProp)
+                valueAliases.set(aliasDeclaration, sourceProp);
+            const sourceShape = resolveObject(initializer);
+            if (sourceShape)
+                objectAliases.set(aliasDeclaration, new Map(sourceShape));
+        }
+        else if (Node.isObjectBindingPattern(declarationName)) {
+            const sourceShape = resolveObject(initializer);
+            if (sourceShape) {
+                const hasInvalidatedBinding = declarationName
+                    .getElements()
+                    .some((element) => reboundDeclarations.has(getDeclarationIdentity(element.getNameNode())));
+                if (!hasInvalidatedBinding)
+                    addBindings(declarationName, sourceShape);
+            }
+        }
+    }
+    const intrinsicDomProps = new Set();
+    const componentEdges = [];
+    const recordForwarding = (tagNameNode, targetProp, sourceProp) => {
+        const tagName = tagNameNode.getText();
+        if (isIntrinsicJsxElement(tagName)) {
+            if (targetProp === sourceProp)
+                intrinsicDomProps.add(sourceProp);
+            return;
+        }
+        const targetComponentIdentity = resolveForwardedComponentIdentity(tagNameNode);
+        if (targetComponentIdentity)
+            componentEdges.push({ sourceProp, targetComponentIdentity, targetProp });
+    };
+    for (const attribute of func.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+        if (!belongsToComponentFunction(attribute))
+            continue;
+        const tagNameNode = getJsxTagNameNode(attribute);
+        if (!tagNameNode)
+            continue;
+        const initializer = attribute.getInitializer();
+        if (!initializer || !Node.isJsxExpression(initializer))
+            continue;
+        const sourceProp = resolveValue(initializer.getExpression());
+        if (sourceProp)
+            recordForwarding(tagNameNode, attribute.getNameNode().getText(), sourceProp);
+    }
+    for (const spread of func.getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)) {
+        if (!belongsToComponentFunction(spread))
+            continue;
+        const tagNameNode = getJsxTagNameNode(spread);
+        if (!tagNameNode)
+            continue;
+        const shape = resolveObject(spread.getExpression());
+        for (const [targetProp, sourceProp] of shape ?? [])
+            recordForwarding(tagNameNode, targetProp, sourceProp);
+    }
+    return { intrinsicDomProps, componentEdges };
+}

package/dist/src/extract/framework-adapters/react/helpers/collect-react-impl-hints.d.ts

@@ -0,0 +1,5 @@
+import { type ParameterDeclaration } from 'ts-morph';
+import type { FunctionLike } from './resolve-component-function.js';
+import { collectRestBindingNames, isComponentSpreadAttribute, inferPrimitiveDomPropsFromImplementation } from './infer-primitive-dom-props.js';
+export { collectRestBindingNames, isComponentSpreadAttribute, inferPrimitiveDomPropsFromImplementation };
+export declare function hasImplementationChildrenHint(funcNode: FunctionLike, param: ParameterDeclaration): boolean;

package/dist/src/extract/framework-adapters/react/helpers/collect-react-impl-hints.js

@@ -0,0 +1,32 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { collectRestBindingNames, isComponentSpreadAttribute, inferPrimitiveDomPropsFromImplementation, } from './infer-primitive-dom-props.js';
+export { collectRestBindingNames, isComponentSpreadAttribute, inferPrimitiveDomPropsFromImplementation };
+export function hasImplementationChildrenHint(funcNode, param) {
+    const nameNode = param.getNameNode();
+    const body = funcNode.getBody();
+    if (!body)
+        return false;
+    if (Node.isObjectBindingPattern(nameNode)) {
+        for (const element of nameNode.getElements()) {
+            if (element.getNameNode().getText() === 'children')
+                return true;
+        }
+        const restBindingNames = collectRestBindingNames(nameNode);
+        if (restBindingNames.size === 0)
+            return false;
+        return body
+            .getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)
+            .some((attr) => isComponentSpreadAttribute(attr, restBindingNames));
+    }
+    if (!Node.isIdentifier(nameNode))
+        return false;
+    const paramName = nameNode.getText();
+    if (body
+        .getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)
+        .some((expr) => expr.getExpression().getText() === paramName && expr.getName() === 'children')) {
+        return true;
+    }
+    return body
+        .getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)
+        .some((attr) => isComponentSpreadAttribute(attr, new Set([paramName])));
+}

package/dist/src/extract/framework-adapters/react/helpers/detect-dom-is-pure-wrapper.d.ts

@@ -0,0 +1,2 @@
+import { Node } from 'ts-morph';
+export declare function isPureExpandableDomAttributeWrapperType(typeNode: Node): boolean;

package/dist/src/extract/framework-adapters/react/helpers/detect-dom-is-pure-wrapper.js

@@ -0,0 +1,59 @@
+import { Node } from 'ts-morph';
+import { getTypeReferenceName, getNodeDefinitions } from '../../shared/helpers/tsx-shared.js';
+import { getTypeReferenceTargetNode, getTypeReferenceArguments } from '../../shared/helpers/tsx-node-utils.js';
+import { isExpandableDomAttributeWrapperName } from './dom-attribute-surfaces.js';
+function isPureExpandableDomAttributeWrapperTypeNode(typeNode, seen = new Set()) {
+    if (seen.has(typeNode))
+        return false;
+    seen.add(typeNode);
+    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
+        return isPureExpandableDomAttributeWrapperTypeNode(typeNode.getTypeNode(), seen);
+    }
+    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
+        const childTypes = typeNode.getTypeNodes();
+        return (childTypes.length > 0 && childTypes.every((child) => isPureExpandableDomAttributeWrapperTypeNode(child, seen)));
+    }
+    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
+    if (typeReferenceTarget) {
+        const typeName = getTypeReferenceName(typeNode);
+        if (!typeName)
+            return false;
+        const typeArguments = getTypeReferenceArguments(typeNode);
+        if (isExpandableDomAttributeWrapperName(typeName))
+            return true;
+        if (typeName === 'Omit' ||
+            typeName === 'Partial' ||
+            typeName === 'Readonly' ||
+            typeName === 'Required' ||
+            typeName === 'NonNullable') {
+            const wrappedType = typeArguments[0];
+            return wrappedType ? isPureExpandableDomAttributeWrapperTypeNode(wrappedType, seen) : false;
+        }
+        if (typeName === 'Pick')
+            return false;
+        for (const definition of getNodeDefinitions(typeReferenceTarget)) {
+            const declaration = definition.getDeclarationNode();
+            if (!declaration)
+                continue;
+            if (Node.isInterfaceDeclaration(declaration)) {
+                if (declaration.getMembers().length > 0)
+                    return false;
+                const heritageClauses = declaration.getHeritageClauses();
+                return (heritageClauses.length > 0 &&
+                    heritageClauses.every((clause) => clause
+                        .getTypeNodes()
+                        .every((heritageTypeNode) => isPureExpandableDomAttributeWrapperTypeNode(heritageTypeNode, seen))));
+            }
+            if (Node.isTypeAliasDeclaration(declaration)) {
+                const aliasedTypeNode = declaration.getTypeNode();
+                if (!aliasedTypeNode)
+                    return false;
+                return isPureExpandableDomAttributeWrapperTypeNode(aliasedTypeNode, seen);
+            }
+        }
+    }
+    return false;
+}
+export function isPureExpandableDomAttributeWrapperType(typeNode) {
+    return isPureExpandableDomAttributeWrapperTypeNode(typeNode);
+}

package/dist/src/extract/framework-adapters/react/helpers/detect-dom-type-patterns.d.ts

@@ -0,0 +1,8 @@
+import { Node } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export { isPureExpandableDomAttributeWrapperType } from './detect-dom-is-pure-wrapper.js';
+export { containsImportedOmitWrappedCustomProps } from './detect-omit-wrapped-custom-props.js';
+export { containsSupportedDomPickType, containsAnyPickType, shouldMergeDomSyntaxExtraction, } from './detect-pick-type-patterns.js';
+export { collectExpandableDomAttributeWrapperContexts, getStringLiteralTypeValues, } from './collect-dom-wrapper-contexts.js';
+export declare function getSyntheticDomAttributeProps(typeNode: Node | undefined): RawPropDefinition[];
+export declare function hasSyntheticDomChildren(typeNode: Node | undefined): boolean;

package/dist/src/extract/framework-adapters/react/helpers/detect-dom-type-patterns.js

@@ -0,0 +1,29 @@
+import { getDomAttributeSurface, DOM_ATTRIBUTE_WRAPPERS_WITH_SYNTHETIC_CHILDREN } from './dom-attribute-surfaces.js';
+import { collectExpandableDomAttributeWrapperContexts } from './collect-dom-wrapper-contexts.js';
+export { isPureExpandableDomAttributeWrapperType } from './detect-dom-is-pure-wrapper.js';
+export { containsImportedOmitWrappedCustomProps } from './detect-omit-wrapped-custom-props.js';
+export { containsSupportedDomPickType, containsAnyPickType, shouldMergeDomSyntaxExtraction, } from './detect-pick-type-patterns.js';
+export { collectExpandableDomAttributeWrapperContexts, getStringLiteralTypeValues, } from './collect-dom-wrapper-contexts.js';
+export function getSyntheticDomAttributeProps(typeNode) {
+    if (!typeNode)
+        return [];
+    const contexts = collectExpandableDomAttributeWrapperContexts(typeNode);
+    if (contexts.length === 0)
+        return [];
+    const propsByName = new Map();
+    for (const context of contexts) {
+        for (const prop of getDomAttributeSurface(context.name)) {
+            if (context.excludedProps.has(prop.name))
+                continue;
+            if (propsByName.has(prop.name))
+                continue;
+            propsByName.set(prop.name, prop);
+        }
+    }
+    return [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function hasSyntheticDomChildren(typeNode) {
+    if (!typeNode)
+        return false;
+    return collectExpandableDomAttributeWrapperContexts(typeNode).some((context) => DOM_ATTRIBUTE_WRAPPERS_WITH_SYNTHETIC_CHILDREN.has(context.name));
+}

package/dist/src/extract/framework-adapters/react/helpers/detect-omit-wrapped-custom-props.d.ts

@@ -0,0 +1,2 @@
+import { Node } from 'ts-morph';
+export declare function containsImportedOmitWrappedCustomProps(typeNode: Node, seen?: Set<Node<import("ts-morph").ts.Node>>, originSourceFile?: import("ts-morph").SourceFile, sawOmit?: boolean): boolean;

package/dist/src/extract/framework-adapters/react/helpers/detect-omit-wrapped-custom-props.js

@@ -0,0 +1,64 @@
+import { Node } from 'ts-morph';
+import { getTypeReferenceName, getTypeTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
+import { getTypeReferenceTargetNode } from '../../shared/helpers/tsx-node-utils.js';
+import { isPureExpandableDomAttributeWrapperType } from './detect-dom-is-pure-wrapper.js';
+export function containsImportedOmitWrappedCustomProps(typeNode, seen = new Set(), originSourceFile = typeNode.getSourceFile(), sawOmit = false) {
+    if (seen.has(typeNode))
+        return false;
+    seen.add(typeNode);
+    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
+        return containsImportedOmitWrappedCustomProps(typeNode.getTypeNode(), seen, originSourceFile, sawOmit);
+    }
+    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
+        return typeNode
+            .getTypeNodes()
+            .some((child) => containsImportedOmitWrappedCustomProps(child, seen, originSourceFile, sawOmit));
+    }
+    if (Node.isTypeReference(typeNode) || Node.isExpressionWithTypeArguments(typeNode)) {
+        const typeName = getTypeReferenceName(typeNode);
+        if (!typeName)
+            return false;
+        if (typeName === 'PropsWithChildren') {
+            const wrappedType = typeNode.getTypeArguments()[0];
+            return wrappedType ? containsImportedOmitWrappedCustomProps(wrappedType, seen, originSourceFile, sawOmit) : false;
+        }
+        if (typeName === 'Omit') {
+            const wrappedType = typeNode.getTypeArguments()[0];
+            return wrappedType ? containsImportedOmitWrappedCustomProps(wrappedType, seen, originSourceFile, true) : false;
+        }
+        if (typeName === 'Partial' || typeName === 'Readonly' || typeName === 'Required' || typeName === 'NonNullable') {
+            const wrappedType = typeNode.getTypeArguments()[0];
+            return wrappedType ? containsImportedOmitWrappedCustomProps(wrappedType, seen, originSourceFile, sawOmit) : false;
+        }
+        const targetNode = getTypeReferenceTargetNode(typeNode);
+        for (const declaration of getTypeTargetDeclarations(targetNode, sawOmit)) {
+            if (!declaration)
+                continue;
+            const declarationSourceFile = declaration.getSourceFile();
+            const isImportedDeclaration = declarationSourceFile.getFilePath() !== originSourceFile.getFilePath();
+            if (sawOmit && isImportedDeclaration) {
+                const declarationTypeNode = Node.isTypeAliasDeclaration(declaration) ? declaration.getTypeNode() : declaration;
+                if (!declarationTypeNode || !isPureExpandableDomAttributeWrapperType(declarationTypeNode)) {
+                    return true;
+                }
+            }
+            if (Node.isInterfaceDeclaration(declaration)) {
+                if (declaration
+                    .getHeritageClauses()
+                    .some((clause) => clause
+                    .getTypeNodes()
+                    .some((heritageTypeNode) => containsImportedOmitWrappedCustomProps(heritageTypeNode, seen, originSourceFile, sawOmit)))) {
+                    return true;
+                }
+            }
+            if (Node.isTypeAliasDeclaration(declaration)) {
+                const aliasedTypeNode = declaration.getTypeNode();
+                if (aliasedTypeNode &&
+                    containsImportedOmitWrappedCustomProps(aliasedTypeNode, seen, originSourceFile, sawOmit)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}

package/dist/src/extract/framework-adapters/react/helpers/detect-pick-type-patterns.d.ts

@@ -0,0 +1,4 @@
+import { Node } from 'ts-morph';
+export declare function containsSupportedDomPickType(typeNode: Node, seen?: Set<Node<import("ts-morph").ts.Node>>): boolean;
+export declare function containsAnyPickType(typeNode: Node, seen?: Set<Node<import("ts-morph").ts.Node>>): boolean;
+export declare function shouldMergeDomSyntaxExtraction(typeNode: Node): boolean;

package/dist/src/extract/framework-adapters/react/helpers/detect-pick-type-patterns.js

@@ -0,0 +1,64 @@
+import { Node } from 'ts-morph';
+import { getTypeReferenceName, getTypeTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
+import { getTypeReferenceTargetNode, getTypeReferenceArguments } from '../../shared/helpers/tsx-node-utils.js';
+import { collectExpandableDomAttributeWrapperContexts } from './detect-dom-type-patterns.js';
+function containsPickType(typeNode, seen, mode) {
+    if (seen.has(typeNode))
+        return false;
+    seen.add(typeNode);
+    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
+        return containsPickType(typeNode.getTypeNode(), seen, mode);
+    }
+    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
+        return typeNode.getTypeNodes().some((child) => containsPickType(child, seen, mode));
+    }
+    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
+    if (!typeReferenceTarget)
+        return false;
+    const typeName = getTypeReferenceName(typeNode);
+    if (!typeName)
+        return false;
+    const typeArguments = getTypeReferenceArguments(typeNode);
+    if (typeName === 'Pick') {
+        if (mode === 'any')
+            return true;
+        const sourceTypeNode = typeArguments[0];
+        return sourceTypeNode
+            ? collectExpandableDomAttributeWrapperContexts(sourceTypeNode).length > 0 ||
+                containsPickType(sourceTypeNode, seen, mode)
+            : false;
+    }
+    const wrappedTypeNames = mode === 'any'
+        ? ['PropsWithChildren', 'Omit', 'Partial', 'Readonly', 'Required', 'NonNullable']
+        : ['Omit', 'Partial', 'Readonly', 'Required', 'NonNullable'];
+    if (wrappedTypeNames.includes(typeName)) {
+        const wrappedType = typeArguments[0];
+        return wrappedType ? containsPickType(wrappedType, seen, mode) : false;
+    }
+    for (const declaration of getTypeTargetDeclarations(typeReferenceTarget, mode === 'any')) {
+        if (!declaration)
+            continue;
+        if (Node.isInterfaceDeclaration(declaration)) {
+            if (declaration
+                .getHeritageClauses()
+                .some((clause) => clause.getTypeNodes().some((heritageTypeNode) => containsPickType(heritageTypeNode, seen, mode)))) {
+                return true;
+            }
+        }
+        if (Node.isTypeAliasDeclaration(declaration)) {
+            const aliasedTypeNode = declaration.getTypeNode();
+            if (aliasedTypeNode && containsPickType(aliasedTypeNode, seen, mode))
+                return true;
+        }
+    }
+    return false;
+}
+export function containsSupportedDomPickType(typeNode, seen = new Set()) {
+    return containsPickType(typeNode, seen, 'supported');
+}
+export function containsAnyPickType(typeNode, seen = new Set()) {
+    return containsPickType(typeNode, seen, 'any');
+}
+export function shouldMergeDomSyntaxExtraction(typeNode) {
+    return collectExpandableDomAttributeWrapperContexts(typeNode).length > 0 || containsSupportedDomPickType(typeNode);
+}

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

@@ -0,0 +1,5 @@
+import { Node } from 'ts-morph';
+export declare const TRANSPARENT_POLYMORPHIC_TYPE_NAMES: Set<string>;
+export declare function isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration: Node, typeName: string): boolean;
+export declare function unwrapRepoLocalTransparentPolymorphicWrapper(typeNode: Node, allowWorkspaceImportFallback: boolean): Node | undefined;
+export declare function isRepoLocalSupportedPolymorphicChain(typeNode: Node, seen?: Set<Node<import("ts-morph").ts.Node>>, allowWorkspaceImportFallback?: boolean): boolean;