@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/web-components/helpers/extract-wc-template-content.js

@@ -0,0 +1,49 @@
+import { Node } from 'ts-morph';
+import { loadSourceFile } from './resolve-wc-import.js';
+import { extractSlotsFromTemplate } from './extract-wc-slots.js';
+import { collectHtmlTaggedTemplatesWithHelpers } from './collect-wc-html-templates.js';
+export function extractTemplateContent(classDecl, project) {
+    const templates = [];
+    classDecl.forEachDescendant((node) => {
+        if (!Node.isBinaryExpression(node))
+            return;
+        const leftText = node.getLeft().getText();
+        if (!leftText.includes('.innerHTML'))
+            return;
+        const right = node.getRight();
+        if (Node.isTemplateExpression(right) || Node.isNoSubstitutionTemplateLiteral(right)) {
+            templates.push(right.getText().slice(1, -1));
+        }
+    });
+    const renderMethod = classDecl.getMethod('render');
+    if (renderMethod && !renderMethod.isStatic()) {
+        templates.push(...collectHtmlTaggedTemplatesWithHelpers(renderMethod, project));
+    }
+    const templateGetter = classDecl.getGetAccessor('template');
+    if (templateGetter?.isStatic()) {
+        templateGetter.forEachDescendant((node) => {
+            if (Node.isTaggedTemplateExpression(node)) {
+                const tag = node.getTag();
+                if (tag.getText() === 'html') {
+                    const template = node.getTemplate();
+                    if (Node.isNoSubstitutionTemplateLiteral(template) || Node.isTemplateExpression(template)) {
+                        templates.push(template.getText().slice(1, -1));
+                    }
+                }
+            }
+        });
+    }
+    return templates.join('\n');
+}
+export function extractFastTemplateSlots(classDecl, project) {
+    const sourceFilePath = classDecl.getSourceFile().getFilePath();
+    if (!sourceFilePath.endsWith('.ts') || sourceFilePath.endsWith('.template.ts'))
+        return [];
+    const templatePath = `${sourceFilePath.slice(0, -'.ts'.length)}.template.ts`;
+    const templateFile = loadSourceFile(project, templatePath);
+    if (!templateFile)
+        return [];
+    const fragments = [];
+    fragments.push(...collectHtmlTaggedTemplatesWithHelpers(templateFile, project));
+    return extractSlotsFromTemplate(fragments.join('\n'));
+}

package/dist/src/extract/framework-adapters/web-components/helpers/merge-wc-prop-lists.d.ts

@@ -0,0 +1,9 @@
+import type { RawPropDefinition } from '../../../types/component.js';
+import type { ClassDeclaration } from 'ts-morph';
+export { extractObservedAttributes } from './extract-wc-observed-attrs.js';
+export { extractAccessorProperties } from './extract-wc-accessor-props.js';
+export { extractJsDocAttributeProps } from './extract-wc-jsdoc-attr-props.js';
+export { extractClassProperties } from './extract-wc-class-properties.js';
+export declare function hasShoelaceRuntimeBookkeepingField(classDecl: ClassDeclaration): boolean;
+export declare function mergePropLists(...propLists: RawPropDefinition[][]): RawPropDefinition[];
+export declare function mergeProps(observed: RawPropDefinition[], classProps: RawPropDefinition[]): RawPropDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/merge-wc-prop-lists.js

@@ -0,0 +1,19 @@
+export { extractObservedAttributes } from './extract-wc-observed-attrs.js';
+export { extractAccessorProperties } from './extract-wc-accessor-props.js';
+export { extractJsDocAttributeProps } from './extract-wc-jsdoc-attr-props.js';
+export { extractClassProperties } from './extract-wc-class-properties.js';
+export function hasShoelaceRuntimeBookkeepingField(classDecl) {
+    return classDecl.getProperties().some((property) => property.getName() === 'initialReflectedProperties');
+}
+export function mergePropLists(...propLists) {
+    const merged = new Map();
+    for (const propList of propLists) {
+        for (const prop of propList) {
+            merged.set(prop.name, prop);
+        }
+    }
+    return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function mergeProps(observed, classProps) {
+    return mergePropLists(observed, classProps);
+}

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-base-class.d.ts

@@ -0,0 +1,2 @@
+import { type ClassDeclaration, type Project } from 'ts-morph';
+export declare function getImportedBaseClass(classDecl: ClassDeclaration, project: Project, visitedFiles: Set<string>): ClassDeclaration | null;

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-base-class.js

@@ -0,0 +1,59 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { resolveImportSourcePath } from './resolve-wc-import.js';
+export function getImportedBaseClass(classDecl, project, visitedFiles) {
+    const extendsClause = classDecl
+        .getHeritageClauses()
+        .find((clause) => clause.getToken() === SyntaxKind.ExtendsKeyword);
+    const typeNode = extendsClause?.getTypeNodes()[0];
+    if (!typeNode)
+        return null;
+    const expression = typeNode.getExpression();
+    if (!Node.isIdentifier(expression))
+        return null;
+    const baseName = expression.getText();
+    const importDecl = classDecl
+        .getSourceFile()
+        .getImportDeclarations()
+        .find((decl) => decl.getNamedImports().some((namedImport) => namedImport.getName() === baseName) ||
+        decl.getDefaultImport()?.getText() === baseName);
+    if (!importDecl)
+        return null;
+    const resolvedImportPath = resolveImportSourcePath(classDecl.getSourceFile().getFilePath(), importDecl.getModuleSpecifierValue());
+    if (!resolvedImportPath || visitedFiles.has(resolvedImportPath))
+        return null;
+    visitedFiles.add(resolvedImportPath);
+    let sourceFile = project.getSourceFile(resolvedImportPath);
+    if (!sourceFile) {
+        try {
+            sourceFile = project.addSourceFileAtPath(resolvedImportPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    const directClass = sourceFile.getClass(baseName);
+    if (directClass)
+        return directClass;
+    for (const exportDecl of sourceFile.getExportDeclarations()) {
+        const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+        if (!moduleSpecifier)
+            continue;
+        const reexportPath = resolveImportSourcePath(sourceFile.getFilePath(), moduleSpecifier);
+        if (!reexportPath || visitedFiles.has(reexportPath))
+            continue;
+        visitedFiles.add(reexportPath);
+        let reexportFile = project.getSourceFile(reexportPath);
+        if (!reexportFile) {
+            try {
+                reexportFile = project.addSourceFileAtPath(reexportPath);
+            }
+            catch {
+                continue;
+            }
+        }
+        const reexportedClass = reexportFile.getClass(baseName);
+        if (reexportedClass)
+            return reexportedClass;
+    }
+    return null;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-decorator-tag.d.ts

@@ -0,0 +1,2 @@
+import { type ClassDeclaration } from 'ts-morph';
+export declare function getElementTagNameFromDecorator(classDecl: ClassDeclaration): string | null;

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-decorator-tag.js

@@ -0,0 +1,54 @@
+import { Node } from 'ts-morph';
+function camelToKebab(input) {
+    return input
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+function resolveDecoratorInterpolation(node) {
+    if (Node.isIdentifier(node)) {
+        const definitions = node.getDefinitions();
+        for (const definition of definitions) {
+            const declarationNode = definition.getDeclarationNode();
+            if (!declarationNode)
+                continue;
+            if (Node.isVariableDeclaration(declarationNode)) {
+                const initializer = declarationNode.getInitializer();
+                if (initializer && Node.isStringLiteral(initializer))
+                    return initializer.getLiteralValue();
+            }
+        }
+        const text = node.getText();
+        if (/Prefix$/.test(text))
+            return camelToKebab(text.replace(/Prefix$/, ''));
+    }
+    return null;
+}
+function resolveDecoratorTagArgument(node) {
+    if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node))
+        return node.getLiteralValue();
+    if (!Node.isTemplateExpression(node))
+        return null;
+    let resolved = node.getHead().getLiteralText();
+    for (const span of node.getTemplateSpans()) {
+        const interpolation = resolveDecoratorInterpolation(span.getExpression());
+        if (!interpolation)
+            return null;
+        resolved += interpolation;
+        resolved += span.getLiteral().getLiteralText();
+    }
+    return resolved;
+}
+export function getElementTagNameFromDecorator(classDecl) {
+    for (const decorator of classDecl.getDecorators()) {
+        if (decorator.getName() !== 'customElement')
+            continue;
+        const firstArg = decorator.getArguments()[0];
+        if (!firstArg)
+            continue;
+        const resolved = resolveDecoratorTagArgument(firstArg);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-import-source.d.ts

@@ -0,0 +1,7 @@
+import { Node, type Project, type SourceFile } from 'ts-morph';
+export declare function loadSourceFile(project: Project, filePath: string): SourceFile | null;
+export declare function resolveImportSourcePath(fromFilePath: string, specifier: string): string | null;
+export declare function resolveImportSpecifierSource(declarationNode: Node, sourceFile: SourceFile, project: Project): {
+    sourceFile: SourceFile;
+    importedName: string;
+} | undefined;

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-import-source.js

@@ -0,0 +1,47 @@
+import { dirname, resolve } from 'node:path';
+import { Node } from 'ts-morph';
+export function loadSourceFile(project, filePath) {
+    let sourceFile = project.getSourceFile(filePath);
+    if (sourceFile)
+        return sourceFile;
+    try {
+        sourceFile = project.addSourceFileAtPath(filePath);
+        return sourceFile;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveImportSourcePath(fromFilePath, specifier) {
+    if (specifier.startsWith('.')) {
+        const resolvedPath = resolve(dirname(fromFilePath), specifier);
+        if (resolvedPath.endsWith('.js'))
+            return `${resolvedPath.slice(0, -3)}.ts`;
+        return resolvedPath;
+    }
+    const spectrumPrefix = '@spectrum-web-components/core/components/';
+    if (!specifier.startsWith(spectrumPrefix))
+        return null;
+    const packagesMarker = `${'2nd-gen/packages'}${fromFilePath.includes('\\') ? '\\' : '/'}`;
+    const markerIndex = fromFilePath.lastIndexOf(packagesMarker);
+    if (markerIndex === -1)
+        return null;
+    const packagesRoot = fromFilePath.slice(0, markerIndex + packagesMarker.length - 1);
+    const componentPath = specifier.slice(spectrumPrefix.length);
+    return `${packagesRoot}/core/components/${componentPath}/index.ts`;
+}
+export function resolveImportSpecifierSource(declarationNode, sourceFile, project) {
+    if (!Node.isImportSpecifier(declarationNode))
+        return undefined;
+    const importDecl = declarationNode.getImportDeclaration();
+    const resolvedImportPath = resolveImportSourcePath(sourceFile.getFilePath(), importDecl.getModuleSpecifierValue());
+    if (!resolvedImportPath)
+        return undefined;
+    const importedFile = loadSourceFile(project, resolvedImportPath);
+    if (!importedFile)
+        return undefined;
+    return {
+        sourceFile: importedFile,
+        importedName: declarationNode.getNameNode().getText(),
+    };
+}

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-import.d.ts

@@ -0,0 +1,4 @@
+import { Node, type Project, type SourceFile } from 'ts-morph';
+import { loadSourceFile, resolveImportSourcePath, resolveImportSpecifierSource } from './resolve-wc-import-source.js';
+export { loadSourceFile, resolveImportSourcePath, resolveImportSpecifierSource };
+export declare function resolveStaticStringExpression(node: Node | undefined, sourceFile: SourceFile, project: Project): string | null;

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-import.js

@@ -0,0 +1,93 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { loadSourceFile, resolveImportSourcePath, resolveImportSpecifierSource } from './resolve-wc-import-source.js';
+export { loadSourceFile, resolveImportSourcePath, resolveImportSpecifierSource };
+export function resolveStaticStringExpression(node, sourceFile, project) {
+    if (!node)
+        return null;
+    if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node))
+        return node.getLiteralValue();
+    if (Node.isTemplateExpression(node)) {
+        let resolved = node.getHead().getLiteralText();
+        for (const span of node.getTemplateSpans()) {
+            const interpolation = resolveStaticStringExpression(span.getExpression(), sourceFile, project);
+            if (!interpolation)
+                return null;
+            resolved += interpolation;
+            resolved += span.getLiteral().getLiteralText();
+        }
+        return resolved;
+    }
+    if (Node.isIdentifier(node)) {
+        for (const definition of node.getDefinitions()) {
+            const declarationNode = definition.getDeclarationNode();
+            if (!declarationNode)
+                continue;
+            if (Node.isVariableDeclaration(declarationNode)) {
+                const resolved = resolveStaticStringExpression(declarationNode.getInitializer(), declarationNode.getSourceFile(), project);
+                if (resolved)
+                    return resolved;
+            }
+            if (Node.isImportSpecifier(declarationNode)) {
+                const importedSource = resolveImportSpecifierSource(declarationNode, sourceFile, project);
+                if (!importedSource)
+                    continue;
+                const importedDeclaration = importedSource.sourceFile.getVariableDeclaration(importedSource.importedName);
+                if (!importedDeclaration)
+                    continue;
+                const resolved = resolveStaticStringExpression(importedDeclaration.getInitializer(), importedSource.sourceFile, project);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        const text = node.getText();
+        if (/Prefix$/.test(text))
+            return camelToKebab(text.replace(/Prefix$/, ''));
+        return null;
+    }
+    if (Node.isPropertyAccessExpression(node)) {
+        const target = node.getExpression();
+        if (!Node.isIdentifier(target))
+            return null;
+        const propertyName = node.getName();
+        for (const definition of target.getDefinitions()) {
+            const declarationNode = definition.getDeclarationNode();
+            if (!declarationNode)
+                continue;
+            let variableDeclaration;
+            if (Node.isVariableDeclaration(declarationNode)) {
+                variableDeclaration = declarationNode;
+            }
+            else if (Node.isImportSpecifier(declarationNode)) {
+                const importedSource = resolveImportSpecifierSource(declarationNode, sourceFile, project);
+                if (!importedSource)
+                    continue;
+                variableDeclaration = importedSource.sourceFile.getVariableDeclaration(importedSource.importedName);
+            }
+            if (!variableDeclaration)
+                continue;
+            let objectLiteral = variableDeclaration.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+            const initializer = variableDeclaration.getInitializer();
+            if (!objectLiteral &&
+                initializer &&
+                Node.isCallExpression(initializer) &&
+                initializer.getExpression().getText() === 'Object.freeze') {
+                objectLiteral = initializer.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression) ?? undefined;
+            }
+            const property = objectLiteral
+                ?.getProperties()
+                .find((prop) => Node.isPropertyAssignment(prop) && prop.getName() === propertyName);
+            if (!property)
+                continue;
+            const resolved = resolveStaticStringExpression(property.getInitializer(), variableDeclaration.getSourceFile(), project);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return null;
+}
+function camelToKebab(input) {
+    return input
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-sibling-definition.d.ts

@@ -0,0 +1,4 @@
+import { type ClassDeclaration, type Project, type SourceFile } from 'ts-morph';
+export declare function buildTagNameMap(sourceFile: SourceFile): Map<string, string>;
+export declare function getElementTagNameFromSiblingDefine(classDecl: ClassDeclaration, project: Project): string | null;
+export declare function getElementTagNameFromFastDefinition(classDecl: ClassDeclaration, project: Project): string | null;

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-sibling-definition.js

@@ -0,0 +1,79 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { resolveStaticStringExpression, loadSourceFile } from './resolve-wc-import.js';
+export function buildTagNameMap(sourceFile) {
+    const tagNameMap = new Map();
+    sourceFile.forEachDescendant((node) => {
+        if (!Node.isCallExpression(node))
+            return;
+        const expr = node.getExpression();
+        if (!Node.isPropertyAccessExpression(expr) || expr.getName() !== 'define')
+            return;
+        if (expr.getExpression().getText() !== 'customElements')
+            return;
+        const args = node.getArguments();
+        if (args.length < 2)
+            return;
+        const tagArg = args[0];
+        const classArg = args[1];
+        if (!Node.isStringLiteral(tagArg))
+            return;
+        tagNameMap.set(classArg.getText(), tagArg.getLiteralValue());
+    });
+    return tagNameMap;
+}
+export function getElementTagNameFromSiblingDefine(classDecl, project) {
+    const sourceFilePath = classDecl.getSourceFile().getFilePath();
+    if (!sourceFilePath.endsWith('.component.ts'))
+        return null;
+    const siblingPath = `${sourceFilePath.slice(0, -'.component.ts'.length)}.ts`;
+    let siblingFile = project.getSourceFile(siblingPath);
+    if (!siblingFile) {
+        try {
+            siblingFile = project.addSourceFileAtPath(siblingPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    const className = classDecl.getName();
+    if (!className)
+        return null;
+    for (const node of siblingFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expression = node.getExpression();
+        if (!Node.isPropertyAccessExpression(expression) || expression.getName() !== 'define')
+            continue;
+        if (expression.getExpression().getText() !== className)
+            continue;
+        const tagArg = node.getArguments()[0];
+        if (!tagArg || !Node.isStringLiteral(tagArg))
+            continue;
+        return tagArg.getLiteralValue();
+    }
+    return null;
+}
+export function getElementTagNameFromFastDefinition(classDecl, project) {
+    const sourceFilePath = classDecl.getSourceFile().getFilePath();
+    if (!sourceFilePath.endsWith('.ts') || sourceFilePath.endsWith('.definition.ts'))
+        return null;
+    const definitionPath = `${sourceFilePath.slice(0, -'.ts'.length)}.definition.ts`;
+    const definitionFile = loadSourceFile(project, definitionPath);
+    if (!definitionFile)
+        return null;
+    for (const callExpr of definitionFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expression = callExpr.getExpression();
+        if (!Node.isPropertyAccessExpression(expression) || expression.getName() !== 'compose')
+            continue;
+        const options = callExpr.getArguments()[0];
+        if (!options || !Node.isObjectLiteralExpression(options))
+            continue;
+        const nameProperty = options
+            .getProperties()
+            .find((prop) => Node.isPropertyAssignment(prop) && (prop.getName() === 'name' || prop.getName() === 'baseName'));
+        if (!nameProperty)
+            continue;
+        const resolved = resolveStaticStringExpression(nameProperty.getInitializer(), definitionFile, project);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-tag-name.d.ts

@@ -0,0 +1,7 @@
+import { type ClassDeclaration, type Project } from 'ts-morph';
+import { getElementTagNameFromDecorator } from './resolve-wc-decorator-tag.js';
+import { buildTagNameMap, getElementTagNameFromSiblingDefine, getElementTagNameFromFastDefinition } from './resolve-wc-sibling-definition.js';
+export { buildTagNameMap, getElementTagNameFromDecorator, getElementTagNameFromSiblingDefine, getElementTagNameFromFastDefinition, };
+export declare function chooseComponentName(classDecl: ClassDeclaration, className: string, tagName: string | undefined): string;
+export declare function getElementTagNameFromJsDoc(classDecl: ClassDeclaration): string | null;
+export declare function resolveWcTagName(classDecl: ClassDeclaration, tagNameMap: Map<string, string>, project: Project): string | undefined;

package/dist/src/extract/framework-adapters/web-components/helpers/resolve-wc-tag-name.js

@@ -0,0 +1,62 @@
+import { basename } from 'node:path';
+import { kebabToPascal } from '../../shared/helpers/tsx-shared.js';
+import { getElementTagNameFromDecorator } from './resolve-wc-decorator-tag.js';
+import { buildTagNameMap, getElementTagNameFromSiblingDefine, getElementTagNameFromFastDefinition, } from './resolve-wc-sibling-definition.js';
+export { buildTagNameMap, getElementTagNameFromDecorator, getElementTagNameFromSiblingDefine, getElementTagNameFromFastDefinition, };
+function normalizeComponentName(input) {
+    return input.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+}
+function shouldPreferTagName(className, tagName) {
+    const pascalTagName = kebabToPascal(tagName);
+    if (className.startsWith('HTML') && className.endsWith('Element'))
+        return true;
+    if (className.endsWith('Element'))
+        return true;
+    if (normalizeComponentName(className) === normalizeComponentName(pascalTagName))
+        return false;
+    return false;
+}
+function getFileDerivedComponentName(sourceFile) {
+    const baseName = basename(sourceFile.getFilePath())
+        .replace(/\.[^.]+$/, '')
+        .replace(/\.component$/, '');
+    return kebabToPascal(baseName);
+}
+export function chooseComponentName(classDecl, className, tagName) {
+    if (!tagName)
+        return className;
+    const tagDerivedName = kebabToPascal(tagName);
+    const fileDerivedName = getFileDerivedComponentName(classDecl.getSourceFile());
+    if (normalizeComponentName(className) === normalizeComponentName(tagDerivedName))
+        return className;
+    if (normalizeComponentName(className) === normalizeComponentName(fileDerivedName))
+        return className;
+    if (fileDerivedName && tagDerivedName.endsWith(fileDerivedName))
+        return fileDerivedName;
+    if (shouldPreferTagName(className, tagName))
+        return tagDerivedName;
+    return className;
+}
+export function getElementTagNameFromJsDoc(classDecl) {
+    for (const doc of classDecl.getJsDocs()) {
+        for (const tag of doc.getTags()) {
+            if (tag.getTagName() !== 'element')
+                continue;
+            const comment = tag.getCommentText();
+            if (comment)
+                return comment.trim();
+        }
+    }
+    return null;
+}
+export function resolveWcTagName(classDecl, tagNameMap, project) {
+    const className = classDecl.getName();
+    if (!className)
+        return undefined;
+    return (tagNameMap.get(className) ??
+        getElementTagNameFromSiblingDefine(classDecl, project) ??
+        getElementTagNameFromDecorator(classDecl) ??
+        getElementTagNameFromJsDoc(classDecl) ??
+        getElementTagNameFromFastDefinition(classDecl, project) ??
+        undefined);
+}

package/dist/src/extract/helpers/evidence/ast/collect-structural-jsx-evidence.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDeclaration, type ArrowFunction, type FunctionExpression } from 'ts-morph';
+type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression;
+export declare function collectRenderedComponentReferences(funcNode: FunctionLike, componentNames: ReadonlySet<string>, ownComponentName: string): string[];
+export declare function collectArrayMapRenderComponentReferences(funcNode: FunctionLike, componentNames: ReadonlySet<string>, ownComponentName: string, propTypesByName: ReadonlyMap<string, string>): string[];
+export {};

package/dist/src/extract/helpers/evidence/ast/collect-structural-jsx-evidence.js

@@ -0,0 +1,63 @@
+import { SyntaxKind } from 'ts-morph';
+import { isIntrinsicJsxElement } from '../../../framework-adapters/shared/helpers/tsx-shared.js';
+import { getReturnedJsxTagName, isJsxCarryingTypeText } from './get-jsx-ast-data.js';
+export function collectRenderedComponentReferences(funcNode, componentNames, ownComponentName) {
+    const found = new Set();
+    const jsxElements = [
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ];
+    for (const jsxElement of jsxElements) {
+        const tagName = jsxElement.getTagNameNode().getText();
+        if (isIntrinsicJsxElement(tagName))
+            continue;
+        if (tagName === ownComponentName)
+            continue;
+        if (!componentNames.has(tagName))
+            continue;
+        found.add(tagName);
+    }
+    return [...found].sort();
+}
+export function collectArrayMapRenderComponentReferences(funcNode, componentNames, ownComponentName, propTypesByName) {
+    const found = new Set();
+    const propNames = new Set(propTypesByName.keys());
+    const renderCountByComponent = new Map();
+    for (const jsxElement of [
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ]) {
+        const tagName = jsxElement.getTagNameNode().getText();
+        if (isIntrinsicJsxElement(tagName) || tagName === ownComponentName || !componentNames.has(tagName))
+            continue;
+        renderCountByComponent.set(tagName, (renderCountByComponent.get(tagName) ?? 0) + 1);
+    }
+    for (const callExpr of funcNode.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const callee = callExpr.getExpression();
+        if (!callee.isKind(SyntaxKind.PropertyAccessExpression))
+            continue;
+        if (callee.getName() !== 'map')
+            continue;
+        const receiver = callee.getExpression();
+        if (!receiver.isKind(SyntaxKind.Identifier))
+            continue;
+        const propName = receiver.getText();
+        if (!propNames.has(propName))
+            continue;
+        const propTypeText = propTypesByName.get(propName) ?? '';
+        if (isJsxCarryingTypeText(propTypeText))
+            continue;
+        const [callbackArg] = callExpr.getArguments();
+        if (!callbackArg)
+            continue;
+        if (!callbackArg.isKind(SyntaxKind.ArrowFunction) && !callbackArg.isKind(SyntaxKind.FunctionExpression))
+            continue;
+        const returnedJsxTag = getReturnedJsxTagName(callbackArg);
+        if (!returnedJsxTag || returnedJsxTag === ownComponentName || !componentNames.has(returnedJsxTag))
+            continue;
+        if ((renderCountByComponent.get(returnedJsxTag) ?? 0) !== 1)
+            continue;
+        found.add(returnedJsxTag);
+    }
+    return [...found].sort();
+}

package/dist/src/extract/helpers/evidence/ast/detect-react-node-types.d.ts

@@ -0,0 +1,2 @@
+export declare function isArrayReactNodeType(typeText: string): boolean;
+export declare function isReactNodeType(typeText: string): boolean;

package/dist/src/extract/helpers/evidence/ast/detect-react-node-types.js

@@ -0,0 +1,24 @@
+const REACT_NODE_EXACT_PATTERNS = ['ReactNode', 'React.ReactNode', 'ReactElement', 'React.ReactElement', 'JSX.Element'];
+function normalizeReactNodeType(typeText) {
+    return typeText
+        .replace(/\s+/g, ' ')
+        .trim()
+        .split('|')
+        .map((part) => part.trim())
+        .filter((part) => part !== 'null' && part !== 'undefined')
+        .join(' | ');
+}
+export function isArrayReactNodeType(typeText) {
+    const stripped = normalizeReactNodeType(typeText);
+    for (const pattern of REACT_NODE_EXACT_PATTERNS) {
+        if (stripped === `${pattern}[]` || stripped === `Array<${pattern}>`)
+            return true;
+    }
+    return false;
+}
+export function isReactNodeType(typeText) {
+    const stripped = normalizeReactNodeType(typeText);
+    if (REACT_NODE_EXACT_PATTERNS.includes(stripped))
+        return true;
+    return isArrayReactNodeType(typeText);
+}

package/dist/src/extract/helpers/evidence/ast/get-jsx-ast-data.d.ts

@@ -0,0 +1,14 @@
+import { Node, type ArrowFunction, type FunctionExpression, type SourceFile } from 'ts-morph';
+/** Collects all names bound in the file via imports or top-level declarations. */
+export declare function collectLocallyBoundNames(sourceFile: SourceFile): Set<string>;
+/**
+ * Returns the tag identifier of the JSX element a callback returns, or
+ * `undefined` if the callback doesn't return exactly one identifier-tagged JSX element.
+ */
+export declare function getReturnedJsxTagName(callback: ArrowFunction | FunctionExpression): string | undefined;
+/** Unwraps a JSX node from an expression body, block body return, or parenthesized expression. */
+export declare function unwrapReturnedJsx(bodyOrExpr: Node): Node | undefined;
+/** Returns the single JSX child of a fragment, or undefined if the fragment has 0 or 2+ children. */
+export declare function unwrapSingleJsxChildOfFragment(fragment: Node): Node | undefined;
+/** Returns true when the type text refers to a React JSX-carrying type (ReactNode, ReactElement, JSX.Element). */
+export declare function isJsxCarryingTypeText(typeText: string): boolean;