@contentful/experience-design-system-extraction 2.34.5-dev-build-d08439d.0 → 2.34.5-dev-build-5e798cb1.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-extraction",
-  "version": "2.34.5-dev-build-d08439d.0",
+  "version": "2.34.5-dev-build-5e798cb1.0",
   "description": "Component extraction engine for the Contentful Experience Design System SDK",
   "license": "MIT",
   "type": "module",

package/dist/src/extract/astro.js

@@ -1,5 +1,5 @@
-import { basename } from 'node:path';
 import os from 'node:os';
+import { basename } from 'node:path';
 import { Project, Node } from 'ts-morph';
 import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
 import { resolveTypeProperty } from './resolve-type-property.js';
@@ -217,10 +217,9 @@ function extractFromAstroFile(filePath, source) {
         slots,
     };
 }
-const ASTRO_EXTRACT_CONCURRENCY = Number(process.env['EDS_EXTRACT_CONCURRENCY'] ?? 0) || os.cpus().length;
 export async function extractAstroComponents(filePaths, onProgress) {
     const astroFiles = filePaths.filter((f) => f.endsWith('.astro'));
-    const { items: components, warnings } = await runFileExtractionWorkers(astroFiles, ASTRO_EXTRACT_CONCURRENCY, async (filePath, source) => ({
+    const { items: components, warnings } = await runFileExtractionWorkers(astroFiles, os.cpus().length, async (filePath, source) => ({
         item: extractFromAstroFile(filePath, source),
     }), (filePath, error) => `Failed to extract from ${filePath}: ${error instanceof Error ? error.message : String(error)}`, onProgress);
     return createSortedExtractionResult(components, warnings);

package/dist/src/extract/react.js

@@ -3,7 +3,7 @@ import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getType
 import { shouldBeSlot } from './slot-detection.js';
 import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc } from './slot-allowed-components.js';
 import { getSourceLineMetadata } from './source-line-metadata.js';
-import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, } from './structural-slot-evidence.js';
+import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from './structural-slot-evidence.js';
 const REACT_ELEMENT_GENERIC_TEST = /(?:React\.)?ReactElement\s*<\s*[A-Za-z_$][\w$.]*/;
 function isReactElementGenericSlotType(typeText) {
     return REACT_ELEMENT_GENERIC_TEST.test(typeText);
@@ -1705,13 +1705,32 @@ export async function extractReactComponents(filePaths) {
     for (const c of components) {
         const fromFile = structuralNamesForFile(c.source);
         const fromRender = c._funcNode ? collectRenderedComponentReferences(c._funcNode, componentNames, c.name) : [];
-        const structural = new Set([...fromFile, ...fromRender]);
+        const propTypesByName = new Map(c.props.map((p) => [p.name, p.type]));
+        const fromArrayMap = c._funcNode
+            ? collectArrayMapRenderComponentReferences(c._funcNode, componentNames, c.name, propTypesByName)
+            : [];
+        const structural = new Set([...fromFile, ...fromRender, ...fromArrayMap]);
         if (structural.size === 0)
             continue;
+        // Signal D — array-map render — is the only signal that can imply an
+        // authorable compositional slot the parent didn't declare. When it fires
+        // and the parent has no declared slots at all, synthesise a default
+        // `children` slot so the evidence has somewhere to land. Signals A/B/C
+        // still only decorate existing slots to keep the current provenance
+        // guarantees intact.
+        const synthesisedSlot = fromArrayMap.length > 0 && c.slots.length === 0 ? { name: 'children', isDefault: true } : undefined;
+        if (synthesisedSlot) {
+            c.slots.push(synthesisedSlot);
+        }
         for (const slot of c.slots) {
             if (slot.allowedComponents && slot.allowedComponents.length > 0)
                 continue;
-            slot.structuralAllowedComponents = [...structural].sort();
+            // Synthesised slots carry ONLY Signal D's mapped children — the strict
+            // signal is what earned the slot; unioning in Signal C's render-body
+            // hits would smuggle private structural pieces (icons, headings) into
+            // an authorable slot the caller can't actually compose against.
+            // Declared slots keep the existing union so A/B/C still enrich them.
+            slot.structuralAllowedComponents = slot === synthesisedSlot ? [...fromArrayMap].sort() : [...structural].sort();
         }
     }
     for (const c of components) {

package/dist/src/extract/structural-slot-evidence.d.ts

@@ -33,4 +33,31 @@ export declare function collectRuntimeTypeCheckComponentReferences(sourceFile: S
  * caller-supplied content — the weakest-trust signal, kept last in the rank.
  */
 export declare function collectRenderedComponentReferences(funcNode: FunctionLike, componentNames: ReadonlySet<string>, ownComponentName: string): string[];
+/**
+ * Signal D — data-array render: the component's render body maps an array-
+ * typed prop to a known child component (e.g. `{items.map(x => <ItemRow
+ * .../>)}` inside a parent whose `items` prop is a plain data array).
+ *
+ * Fires only when ALL strict-gating conditions hold, to keep false positives
+ * off in the common case where mapping over data doesn't imply an authorable
+ * compositional slot. Conditions are listed in check order (cheap fails
+ * first) so the loop-body labels line up 1-to-1 with this list:
+ *
+ *   1. The `.map` callee is an identifier that matches a declared prop on
+ *      the parent (`propNames`).
+ *   2. The prop's declared type text is a plain data array — not
+ *      `ReactNode[]` / `ReactElement<...>[]` / `React.ReactNode[]`, etc.
+ *      (those cases are already covered by the typed-slot pass, so firing
+ *      this signal for them would double-count.)
+ *   3. The callback returns a JSX element whose tag is an identifier
+ *      resolving to a known component (`componentNames`).
+ *   4. That child component is NOT rendered anywhere else in the parent's
+ *      body — the map is the only render site.
+ *
+ * When all four hold, the mapped child is a strong candidate for a
+ * synthesised default slot on the parent — the extractor treats it that way
+ * only when there's no other slot to hang the evidence on (see the caller in
+ * react.ts).
+ */
+export declare function collectArrayMapRenderComponentReferences(funcNode: FunctionLike, componentNames: ReadonlySet<string>, ownComponentName: string, propTypesByName: ReadonlyMap<string, string>): string[];
 export {};

package/dist/src/extract/structural-slot-evidence.js

@@ -119,3 +119,160 @@ export function collectRenderedComponentReferences(funcNode, componentNames, own
     }
     return [...found].sort();
 }
+/**
+ * Signal D — data-array render: the component's render body maps an array-
+ * typed prop to a known child component (e.g. `{items.map(x => <ItemRow
+ * .../>)}` inside a parent whose `items` prop is a plain data array).
+ *
+ * Fires only when ALL strict-gating conditions hold, to keep false positives
+ * off in the common case where mapping over data doesn't imply an authorable
+ * compositional slot. Conditions are listed in check order (cheap fails
+ * first) so the loop-body labels line up 1-to-1 with this list:
+ *
+ *   1. The `.map` callee is an identifier that matches a declared prop on
+ *      the parent (`propNames`).
+ *   2. The prop's declared type text is a plain data array — not
+ *      `ReactNode[]` / `ReactElement<...>[]` / `React.ReactNode[]`, etc.
+ *      (those cases are already covered by the typed-slot pass, so firing
+ *      this signal for them would double-count.)
+ *   3. The callback returns a JSX element whose tag is an identifier
+ *      resolving to a known component (`componentNames`).
+ *   4. That child component is NOT rendered anywhere else in the parent's
+ *      body — the map is the only render site.
+ *
+ * When all four hold, the mapped child is a strong candidate for a
+ * synthesised default slot on the parent — the extractor treats it that way
+ * only when there's no other slot to hang the evidence on (see the caller in
+ * react.ts).
+ */
+export function collectArrayMapRenderComponentReferences(funcNode, componentNames, ownComponentName, propTypesByName) {
+    const found = new Set();
+    const propNames = new Set(propTypesByName.keys());
+    const renderCountByComponent = new Map();
+    const bumpRenderCount = (name) => {
+        renderCountByComponent.set(name, (renderCountByComponent.get(name) ?? 0) + 1);
+    };
+    for (const jsxElement of [
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ]) {
+        const tagName = jsxElement.getTagNameNode().getText();
+        if (isIntrinsicJsxElement(tagName))
+            continue;
+        if (tagName === ownComponentName)
+            continue;
+        if (!componentNames.has(tagName))
+            continue;
+        bumpRenderCount(tagName);
+    }
+    for (const callExpr of funcNode.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const callee = callExpr.getExpression();
+        if (!Node.isPropertyAccessExpression(callee))
+            continue;
+        if (callee.getName() !== 'map')
+            continue;
+        // Condition 1: callee's receiver must be a bare prop identifier.
+        const receiver = callee.getExpression();
+        if (!Node.isIdentifier(receiver))
+            continue;
+        const propName = receiver.getText();
+        if (!propNames.has(propName))
+            continue;
+        // Condition 2: prop's declared type must be a plain data array — reject
+        // ReactNode / ReactElement / JSX.Element unions so we don't overlap with
+        // the typed-slot pass.
+        const propTypeText = propTypesByName.get(propName) ?? '';
+        if (isJsxCarryingTypeText(propTypeText))
+            continue;
+        // Condition 3: callback must be a function expression whose return is a
+        // JSX element resolving to a known component.
+        const [callbackArg] = callExpr.getArguments();
+        if (!callbackArg)
+            continue;
+        if (!Node.isArrowFunction(callbackArg) && !Node.isFunctionExpression(callbackArg))
+            continue;
+        const returnedJsxTag = getReturnedJsxTagName(callbackArg);
+        if (!returnedJsxTag)
+            continue;
+        if (returnedJsxTag === ownComponentName)
+            continue;
+        if (!componentNames.has(returnedJsxTag))
+            continue;
+        // Condition 4: the child must ONLY be rendered inside this map. Any
+        // additional render site elsewhere in the parent means it's a private
+        // implementation detail, not a composable slot child.
+        const totalRenders = renderCountByComponent.get(returnedJsxTag) ?? 0;
+        if (totalRenders !== 1)
+            continue;
+        found.add(returnedJsxTag);
+    }
+    return [...found].sort();
+}
+/**
+ * Returns the tag identifier of the JSX element the callback returns, or
+ * `undefined` if the callback doesn't return exactly one identifier-tagged
+ * JSX element. Accepts both arrow-with-expression bodies and function bodies
+ * with a single return statement. Fragment wrappers with a single JSX child
+ * are unwrapped.
+ */
+function getReturnedJsxTagName(callback) {
+    const body = callback.getBody();
+    const jsxNode = unwrapReturnedJsx(body);
+    if (!jsxNode)
+        return undefined;
+    if (Node.isJsxSelfClosingElement(jsxNode) || Node.isJsxOpeningElement(jsxNode)) {
+        return jsxNode.getTagNameNode().getText();
+    }
+    if (Node.isJsxElement(jsxNode)) {
+        return jsxNode.getOpeningElement().getTagNameNode().getText();
+    }
+    return undefined;
+}
+function unwrapReturnedJsx(bodyOrExpr) {
+    // Arrow with expression body: `(x) => <Foo/>` or `(x) => <><Foo/></>`
+    if (Node.isJsxElement(bodyOrExpr) ||
+        Node.isJsxSelfClosingElement(bodyOrExpr) ||
+        Node.isJsxOpeningElement(bodyOrExpr)) {
+        return bodyOrExpr;
+    }
+    if (Node.isJsxFragment(bodyOrExpr)) {
+        return unwrapSingleJsxChildOfFragment(bodyOrExpr);
+    }
+    if (Node.isParenthesizedExpression(bodyOrExpr)) {
+        return unwrapReturnedJsx(bodyOrExpr.getExpression());
+    }
+    // Block body: look for a single `return <Foo/>;` at the top level.
+    if (Node.isBlock(bodyOrExpr)) {
+        const returns = bodyOrExpr.getStatements().filter(Node.isReturnStatement);
+        if (returns.length !== 1)
+            return undefined;
+        const expr = returns[0].getExpression();
+        if (!expr)
+            return undefined;
+        return unwrapReturnedJsx(expr);
+    }
+    return undefined;
+}
+function unwrapSingleJsxChildOfFragment(fragment) {
+    if (!Node.isJsxFragment(fragment))
+        return undefined;
+    const jsxChildren = fragment
+        .getJsxChildren()
+        .filter((child) => Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child));
+    if (jsxChildren.length !== 1)
+        return undefined;
+    return jsxChildren[0];
+}
+const JSX_CARRYING_TYPE_TOKENS = ['ReactNode', 'ReactElement', 'JSX.Element'];
+/**
+ * True if the type text refers to a React-JSX-carrying type. Used to reject
+ * `items: ReactNode[]`-style props from the array-map signal so we don't
+ * overlap with the typed-slot pass, which already handles those.
+ */
+function isJsxCarryingTypeText(typeText) {
+    for (const token of JSX_CARRYING_TYPE_TOKENS) {
+        if (typeText.includes(token))
+            return true;
+    }
+    return false;
+}

package/dist/src/extract/svelte.js

@@ -1,18 +1,17 @@
+import os from 'node:os';
 import { basename, dirname, resolve, join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import os from 'node:os';
 import { parse as parseSvelte } from 'svelte/compiler';
 import { Project, Node, ScriptTarget, ModuleKind, ts } from 'ts-morph';
 import { computeExtractionScore, deriveNeedsReview } from './scoring.js';
 import { extractAllowedComponentsFromTypeText } from './slot-allowed-components.js';
 import { runFileExtractionWorkers } from './file-extraction-workers.js';
 import { resolveLocalModule } from './resolve-local-module.js';
-const SVELTE_EXTRACT_CONCURRENCY = Number(process.env['EDS_EXTRACT_CONCURRENCY'] ?? 0) || os.cpus().length;
 export async function extractSvelteComponents(filePaths, onProgress, opts) {
     const svelteFiles = filePaths.filter((f) => f.endsWith('.svelte'));
     const retryContexts = new Map();
-    const { items: components, warnings } = await runFileExtractionWorkers(svelteFiles, SVELTE_EXTRACT_CONCURRENCY, async (filePath, source) => {
+    const { items: components, warnings } = await runFileExtractionWorkers(svelteFiles, os.cpus().length, async (filePath, source) => {
         const { component, warnings: fileWarnings, retryContext } = await extractFromSvelteFile(filePath, source);
         return { item: component, warnings: fileWarnings, metadata: retryContext };
     }, (filePath, error) => `${getSvelteComponentName(filePath)}: failed to extract from ${filePath} — ${error instanceof Error ? error.message : String(error)}`, onProgress, (filePath, outcome) => {

package/dist/src/extract/vue.js

@@ -1,7 +1,7 @@
+import os from 'node:os';
 import { basename, dirname, resolve, join } from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import os from 'node:os';
 import { parse as parseSFC } from '@vue/compiler-sfc';
 import { Project, Node } from 'ts-morph';
 import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
@@ -20,10 +20,9 @@ const VUE_TYPE_MAP = {
     Date: 'Date',
     Symbol: 'symbol',
 };
-const VUE_EXTRACT_CONCURRENCY = Number(process.env['EDS_EXTRACT_CONCURRENCY'] ?? 0) || os.cpus().length;
 export async function extractVueComponents(filePaths, onProgress) {
     const vueFiles = filePaths.filter((f) => f.endsWith('.vue'));
-    const { items: components, warnings } = await runFileExtractionWorkers(vueFiles, VUE_EXTRACT_CONCURRENCY, async (filePath, source) => {
+    const { items: components, warnings } = await runFileExtractionWorkers(vueFiles, os.cpus().length, async (filePath, source) => {
         const { component, warnings: fileWarnings } = await extractFromVueSFC(filePath, source);
         return { item: component, warnings: fileWarnings };
     }, (filePath, error) => `Failed to extract from ${filePath}: ${error instanceof Error ? error.message : String(error)}`, onProgress);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-extraction",
-  "version": "2.34.5-dev-build-d08439d.0",
+  "version": "2.34.5-dev-build-5e798cb1.0",
   "description": "Component extraction engine for the Contentful Experience Design System SDK",
   "license": "MIT",
   "type": "module",