@contentful/experience-design-system-extraction 2.35.0-alpha.0 → 2.35.0

package/dist/package.json

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

package/dist/src/extract/pipeline.js

@@ -226,6 +226,7 @@ function choosePreferredComponent(existing, candidate) {
 }
 export async function extractComponents(filePaths, onProgress, opts) {
     const filesByExtractor = new Map();
+    const exclusions = [];
     for (const extractor of extractors) {
         filesByExtractor.set(extractor, []);
     }
@@ -234,6 +235,18 @@ export async function extractComponents(filePaths, onProgress, opts) {
             if (extractor.fileFilter(filePath)) {
                 filesByExtractor.get(extractor).push(filePath);
             }
+            else if (extractor.name === 'svelte' && filePath.endsWith('.svelte')) {
+                const filename = filePath.replace(/\\/g, '/').split('/').pop() ?? '';
+                if (/^\+(page|layout|error)\.svelte$/.test(filename)) {
+                    exclusions.push({
+                        itemType: 'file',
+                        name: filename,
+                        source: filePath,
+                        reason: 'SvelteKit route entrypoints are framework-managed, not authorable components',
+                        stage: 'file-filter',
+                    });
+                }
+            }
         }
     }
     const perExtractorFiles = new Map();
@@ -276,6 +289,7 @@ export async function extractComponents(filePaths, onProgress, opts) {
     }
     for (const result of results) {
         allWarnings.push(...result.warnings);
+        exclusions.push(...(result.exclusions ?? []));
         for (const component of result.components) {
             const scopeKey = getFamilyScopeKey(component.source, component.name, topLevelFamiliesByRoot);
             const identityKey = `${component.name}::${scopeKey}`;
@@ -283,6 +297,13 @@ export async function extractComponents(filePaths, onProgress, opts) {
             if (existing) {
                 const selected = choosePreferredComponent(existing, component);
                 allWarnings.push(`Duplicate component "${component.name}" found in ${component.source} (already seen in ${existing.source}); ${selected.reason}`);
+                exclusions.push({
+                    itemType: 'component',
+                    name: selected.loser.name,
+                    source: selected.loser.source,
+                    reason: `duplicate identity; ${selected.reason}`,
+                    stage: 'duplicate-filter',
+                });
                 componentsByKey.set(identityKey, selected.winner);
                 continue;
             }
@@ -303,6 +324,13 @@ export async function extractComponents(filePaths, onProgress, opts) {
     for (const component of allComponents) {
         if (/^use[A-Z]/.test(component.name)) {
             allWarnings.push(`Skipped hook: ${component.name} (hooks are not renderable components)`);
+            exclusions.push({
+                itemType: 'component',
+                name: component.name,
+                source: component.source,
+                reason: 'Hook names are not renderable components',
+                stage: 'component-filter',
+            });
             continue;
         }
         filteredComponents.push(component);
@@ -310,5 +338,6 @@ export async function extractComponents(filePaths, onProgress, opts) {
     return {
         components: filteredComponents.sort((a, b) => a.name.localeCompare(b.name)),
         warnings: allWarnings,
+        exclusions,
     };
 }

package/dist/src/extract/react.js

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind, } from 'ts-morph';
-import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getTsxExtractionContext, getValueTargetDeclarations, getJsxTagNameNode, isIntrinsicJsxElement, resolveDefaultExportName, } from './tsx-shared.js';
+import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getJsxTagNameNode, extractTsxComponents, getRenderableExports, isIntrinsicJsxElement, } from './tsx-shared.js';
 import { shouldBeSlot } from './slot-detection.js';
 import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc } from './slot-allowed-components.js';
 import { getSourceLineMetadata } from './source-line-metadata.js';
@@ -1626,29 +1626,13 @@ function hasImplementationChildrenHint(funcNode, param) {
         .some((attr) => isComponentSpreadAttribute(attr, new Set([paramName])));
 }
 export async function extractReactComponents(filePaths) {
-    const extractionContext = getTsxExtractionContext(filePaths, /\.[jt]sx$/);
-    if (!extractionContext) {
-        return { components: [], warnings: [] };
-    }
-    const { componentFiles, project } = extractionContext;
-    const warnings = [];
-    const components = [];
-    for (const filePath of componentFiles) {
-        try {
-            const sourceFile = project.getSourceFile(filePath);
-            if (!sourceFile)
-                continue;
-            if (isStencilFile(sourceFile))
-                continue;
-            const fileExports = [...sourceFile.getExportedDeclarations().keys()];
-            const isNext = isNextJsComponent(sourceFile.getFilePath(), fileExports);
-            const extracted = extractFromSourceFile(sourceFile, isNext);
-            components.push(...extracted);
-        }
-        catch (e) {
-            warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
+    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 extractFromSourceFile(sourceFile, isNext, exclusions);
+    });
     const propsToComponent = new Map();
     const componentNames = new Set();
     for (const c of components) {
@@ -1690,7 +1674,7 @@ export async function extractReactComponents(filePaths) {
         const cached = structuralByFile.get(filePath);
         if (cached)
             return cached;
-        const sourceFile = project.getSourceFile(filePath);
+        const sourceFile = project?.getSourceFile(filePath);
         if (!sourceFile)
             return [];
         const ctx = { propsToComponent, componentNames };
@@ -1764,24 +1748,16 @@ export async function extractReactComponents(filePaths) {
     return {
         components: components.sort((a, b) => a.name.localeCompare(b.name)),
         warnings,
+        exclusions,
     };
 }
-function extractFromSourceFile(sourceFile, isNext) {
+function extractFromSourceFile(sourceFile, isNext, exclusions) {
     const components = [];
-    const exported = sourceFile.getExportedDeclarations();
     const usesCreateContext = sourceFileUsesCreateContext(sourceFile);
-    for (const [exportKey, declarations] of exported) {
-        let name = exportKey;
-        if (exportKey === 'default') {
-            const defaultExportName = resolveDefaultExportName(declarations, exported, true);
-            if (!defaultExportName)
-                continue;
-            name = defaultExportName;
-        }
-        if (!/^[A-Z]/.test(name))
-            continue;
-        if (name.startsWith('use'))
-            continue;
+    for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
+        allowVariableDeclaration: true,
+        hookReason: 'React hook names are not renderable components',
+    })) {
         const funcNode = resolveBestFunctionNode(declarations);
         if (!funcNode)
             continue;

package/dist/src/extract/tsx-shared.d.ts

@@ -1,11 +1,25 @@
-import { Node, Project, type Type } from 'ts-morph';
+import { Node, Project, type SourceFile, type Type } from 'ts-morph';
+import type { ExtractionExclusion } from '../types.js';
 export declare function getTsxExtractionContext(filePaths: string[], componentFilePattern: RegExp): {
     componentFiles: string[];
     project: Project;
 } | undefined;
+export declare function extractTsxComponents<T>(filePaths: string[], componentFilePattern: RegExp, extract: (sourceFile: SourceFile, exclusions: ExtractionExclusion[]) => T[]): {
+    components: T[];
+    warnings: string[];
+    exclusions: ExtractionExclusion[];
+    project?: Project;
+};
 export declare function resolveDefaultExportName(declarations: Node[], exported: {
     has(name: string): boolean;
 }, allowVariableDeclaration?: boolean): string | undefined;
+export declare function getRenderableExports(sourceFile: SourceFile, exclusions: ExtractionExclusion[], options: {
+    allowVariableDeclaration?: boolean;
+    hookReason: string;
+}): Array<{
+    name: string;
+    declarations: Node[];
+}>;
 export declare function kebabToPascal(input: string): string;
 export declare function extractAllowedValues(type: Type): string[] | undefined;
 /**

package/dist/src/extract/tsx-shared.js

@@ -35,6 +35,28 @@ export function getTsxExtractionContext(filePaths, componentFilePattern) {
         project: createTsxProject(getTsxProjectFiles(filePaths)),
     };
 }
+export function extractTsxComponents(filePaths, componentFilePattern, extract) {
+    const extractionContext = getTsxExtractionContext(filePaths, componentFilePattern);
+    if (!extractionContext) {
+        return { components: [], warnings: [], exclusions: [] };
+    }
+    const { componentFiles, project } = extractionContext;
+    const components = [];
+    const warnings = [];
+    const exclusions = [];
+    for (const filePath of componentFiles) {
+        try {
+            const sourceFile = project.getSourceFile(filePath);
+            if (!sourceFile)
+                continue;
+            components.push(...extract(sourceFile, exclusions));
+        }
+        catch (e) {
+            warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { components, warnings, exclusions, project };
+}
 export function resolveDefaultExportName(declarations, exported, allowVariableDeclaration = false) {
     const declaration = declarations[0];
     const name = Node.isFunctionDeclaration(declaration)
@@ -46,6 +68,29 @@ export function resolveDefaultExportName(declarations, exported, allowVariableDe
         return undefined;
     return name;
 }
+export function getRenderableExports(sourceFile, exclusions, options) {
+    const renderable = [];
+    const exported = sourceFile.getExportedDeclarations();
+    for (const [exportKey, declarations] of exported) {
+        const name = exportKey === 'default'
+            ? resolveDefaultExportName(declarations, exported, options.allowVariableDeclaration)
+            : exportKey;
+        if (!name || !/^[A-Z]/.test(name))
+            continue;
+        if (name.startsWith('use')) {
+            exclusions.push({
+                itemType: 'component',
+                name,
+                source: sourceFile.getFilePath(),
+                reason: options.hookReason,
+                stage: 'component-filter',
+            });
+            continue;
+        }
+        renderable.push({ name, declarations });
+    }
+    return renderable;
+}
 export function kebabToPascal(input) {
     return input
         .split('-')

package/dist/src/extract/vue-tsx.js

@@ -1,44 +1,18 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { extractAllowedValues, getTypeReferenceName, getTypeTargetDeclarations, getTsxExtractionContext, getValueTargetDeclarations, resolveDefaultExportName, } from './tsx-shared.js';
+import { extractAllowedValues, extractTsxComponents, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getRenderableExports, } from './tsx-shared.js';
 export async function extractVueTsxComponents(filePaths) {
-    const extractionContext = getTsxExtractionContext(filePaths, /\.tsx$/);
-    if (!extractionContext) {
-        return { components: [], warnings: [] };
-    }
-    const { componentFiles, project } = extractionContext;
-    const warnings = [];
-    const components = [];
-    for (const filePath of componentFiles) {
-        try {
-            const sourceFile = project.getSourceFile(filePath);
-            if (!sourceFile)
-                continue;
-            components.push(...extractFromSourceFile(sourceFile));
-        }
-        catch (e) {
-            warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
+    const { components, warnings, exclusions } = extractTsxComponents(filePaths, /\.tsx$/, extractFromSourceFile);
     return {
         components: components.sort((a, b) => a.name.localeCompare(b.name)),
         warnings,
+        exclusions,
     };
 }
-function extractFromSourceFile(sourceFile) {
+function extractFromSourceFile(sourceFile, exclusions) {
     const components = [];
-    const exported = sourceFile.getExportedDeclarations();
-    for (const [exportKey, declarations] of exported) {
-        let name = exportKey;
-        if (exportKey === 'default') {
-            const defaultExportName = resolveDefaultExportName(declarations, exported);
-            if (!defaultExportName)
-                continue;
-            name = defaultExportName;
-        }
-        if (!/^[A-Z]/.test(name))
-            continue;
-        if (name.startsWith('use'))
-            continue;
+    for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
+        hookReason: 'Vue composition hook names are not renderable components',
+    })) {
         const component = extractVueTsxComponent(declarations, name, sourceFile);
         if (component) {
             components.push(component);

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-export type { RawComponentDefinition, RawPropDefinition, RawSlotDefinition, ComponentExtractionResult, ExtractorProgress, ExtractorOptions, ComponentExtractor, ExtractionValidationIssue, ExtractionValidationIssueCode, } from './types.js';
+export type { RawComponentDefinition, RawPropDefinition, RawSlotDefinition, ComponentExtractionResult, ExtractionExclusion, ExtractorProgress, ExtractorOptions, ComponentExtractor, ExtractionValidationIssue, ExtractionValidationIssueCode, } from './types.js';
 export { stripScoringFields } from './types.js';
 export { extractComponents } from './extract/pipeline.js';
 export { extractReactComponents } from './extract/react.js';

package/dist/src/types.d.ts

@@ -62,6 +62,15 @@ export interface RawComponentDefinition {
 export interface ComponentExtractionResult {
     components: RawComponentDefinition[];
     warnings: string[];
+    exclusions?: ExtractionExclusion[];
+}
+/** A deterministic item removed before the interactive scope gate. */
+export interface ExtractionExclusion {
+    itemType: 'component' | 'file' | 'prop';
+    name: string;
+    source?: string;
+    reason: string;
+    stage: string;
 }
 export type ExtractorProgress = {
     filesProcessed: number;

package/package.json

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