@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/extractor.js

@@ -1,31 +0,0 @@
-import { extractTsxComponents } from '../shared/helpers/tsx-shared.js';
-import { resolveReactAllowedComponents } from './helpers/extract-react-allowed-components.js';
-import { synthesizeReactStructuralSlots } from './helpers/synthesize-react-structural-slots.js';
-import { resolveReactPropForwarding } from './helpers/resolve-react-prop-forwarding.js';
-import { extractFromReactSourceFile } from './helpers/extract-from-react-source-file.js';
-function isStencilFile(sourceFile) {
-    return sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === '@stencil/core');
-}
-function isNextJsComponent(filePath, exportedNames) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const isAppRouterFile = /\/app\/.*\/(page|layout)\.[jt]sx?$/.test(normalized);
-    const hasNextExports = exportedNames.some((name) => name === 'generateMetadata' || name === 'generateStaticParams');
-    return isAppRouterFile || hasNextExports;
-}
-export async function extractReactComponents(filePaths) {
-    const { components, warnings, exclusions, project } = extractTsxComponents(filePaths, /\.[jt]sx$/, (sourceFile, exclusions) => {
-        if (isStencilFile(sourceFile))
-            return [];
-        const fileExports = [...sourceFile.getExportedDeclarations().keys()];
-        const isNext = isNextJsComponent(sourceFile.getFilePath(), fileExports);
-        return extractFromReactSourceFile(sourceFile, isNext, exclusions);
-    });
-    resolveReactAllowedComponents(components);
-    synthesizeReactStructuralSlots(components, project);
-    resolveReactPropForwarding(components);
-    return {
-        components: components.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings,
-        exclusions,
-    };
-}

package/dist/src/extract/framework-adapters/react/helpers/collect-dom-wrapper-contexts.d.ts

@@ -1,4 +0,0 @@
-import { Node } from 'ts-morph';
-import { type ExpandableDomAttributeWrapperContext } from './dom-attribute-surfaces.js';
-export declare function getStringLiteralTypeValues(typeNode: Node): string[];
-export declare function collectExpandableDomAttributeWrapperContexts(typeNode: Node, seen?: Set<Node<import("ts-morph").ts.Node>>, excludedProps?: Set<string>): ExpandableDomAttributeWrapperContext[];

package/dist/src/extract/framework-adapters/react/helpers/collect-dom-wrapper-contexts.js

@@ -1,73 +0,0 @@
-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';
-export function getStringLiteralTypeValues(typeNode) {
-    if (Node.isLiteralTypeNode(typeNode)) {
-        const literal = typeNode.getLiteral();
-        if (Node.isStringLiteral(literal))
-            return [literal.getLiteralText()];
-    }
-    if (!Node.isUnionTypeNode(typeNode))
-        return [];
-    return typeNode.getTypeNodes().flatMap((n) => getStringLiteralTypeValues(n));
-}
-export function collectExpandableDomAttributeWrapperContexts(typeNode, seen = new Set(), excludedProps = new Set()) {
-    if (seen.has(typeNode))
-        return [];
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
-        return collectExpandableDomAttributeWrapperContexts(typeNode.getTypeNode(), seen, excludedProps);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        return typeNode
-            .getTypeNodes()
-            .flatMap((child) => collectExpandableDomAttributeWrapperContexts(child, seen, excludedProps));
-    }
-    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
-    if (typeReferenceTarget) {
-        const typeName = getTypeReferenceName(typeNode);
-        if (!typeName)
-            return [];
-        const typeArguments = getTypeReferenceArguments(typeNode);
-        if (isExpandableDomAttributeWrapperName(typeName)) {
-            return [{ name: typeName, excludedProps: new Set(excludedProps) }];
-        }
-        if (typeName === 'Omit') {
-            const [wrappedType, omittedProps] = typeArguments;
-            if (!wrappedType)
-                return [];
-            const nextExcludedProps = new Set(excludedProps);
-            if (omittedProps) {
-                for (const value of getStringLiteralTypeValues(omittedProps))
-                    nextExcludedProps.add(value);
-            }
-            return collectExpandableDomAttributeWrapperContexts(wrappedType, seen, nextExcludedProps);
-        }
-        if (typeName === 'Partial' || typeName === 'Readonly' || typeName === 'Required' || typeName === 'NonNullable') {
-            const wrappedType = typeArguments[0];
-            if (!wrappedType)
-                return [];
-            return collectExpandableDomAttributeWrapperContexts(wrappedType, seen, excludedProps);
-        }
-        for (const definition of getNodeDefinitions(typeReferenceTarget)) {
-            const declaration = definition.getDeclarationNode();
-            if (!declaration)
-                continue;
-            if (Node.isInterfaceDeclaration(declaration)) {
-                return declaration
-                    .getHeritageClauses()
-                    .flatMap((clause) => clause
-                    .getTypeNodes()
-                    .flatMap((heritageTypeNode) => collectExpandableDomAttributeWrapperContexts(heritageTypeNode, seen, excludedProps)));
-            }
-            if (Node.isTypeAliasDeclaration(declaration)) {
-                const aliasedTypeNode = declaration.getTypeNode();
-                if (!aliasedTypeNode)
-                    return [];
-                return collectExpandableDomAttributeWrapperContexts(aliasedTypeNode, seen, excludedProps);
-            }
-        }
-    }
-    return [];
-}

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

@@ -1,14 +0,0 @@
-import { type ParameterDeclaration } from 'ts-morph';
-import { type FunctionLike } from './resolve-component-function.js';
-export type PropForwardingEdge = {
-    sourceProp: string;
-    targetComponentIdentity: string;
-    targetProp: string;
-};
-export type PropDataflow = {
-    intrinsicDomProps: Set<string>;
-    componentEdges: PropForwardingEdge[];
-};
-export declare function getComponentIdentity(func: FunctionLike): string;
-/** Trace only statically resolvable, component-local prop dataflow into JSX. */
-export declare function collectPropDataflow(func: FunctionLike, param: ParameterDeclaration, availablePropNames: Set<string>): PropDataflow;

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

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

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

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

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

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

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

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

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

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

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

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

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