@contentful/experience-design-system-extraction 2.34.5-dev-build-12a524fb.0 → 2.34.5-dev-build-5cd8bcd6.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-extraction",
-  "version": "2.34.5-dev-build-12a524fb.0",
+  "version": "2.34.5-dev-build-5cd8bcd6.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, extractTsxComponents, getValueTargetDeclarations, getJsxTagNameNode, isIntrinsicJsxElement, isCompositionHookName, resolveComponentExportName, } 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,18 @@ function hasImplementationChildrenHint(funcNode, param) {
         .some((attr) => isComponentSpreadAttribute(attr, new Set([paramName])));
 }
 export async function extractReactComponents(filePaths) {
-    const extractionContext = getTsxExtractionContext(filePaths, /\.[jt]sx$/);
+    const exclusions = [];
+    const extractionContext = extractTsxComponents(filePaths, /\.[jt]sx$/, (sourceFile) => {
+        if (isStencilFile(sourceFile))
+            return [];
+        const fileExports = [...sourceFile.getExportedDeclarations().keys()];
+        const isNext = isNextJsComponent(sourceFile.getFilePath(), fileExports);
+        return extractFromSourceFile(sourceFile, isNext, exclusions);
+    });
     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 { project, components, warnings } = extractionContext;
     const propsToComponent = new Map();
     const componentNames = new Set();
     for (const c of components) {
@@ -1764,24 +1753,27 @@ 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))
+        const name = resolveComponentExportName(exportKey, declarations, exported, true);
+        if (!name)
             continue;
-        if (name.startsWith('use'))
+        if (isCompositionHookName(name)) {
+            exclusions.push({
+                itemType: 'component',
+                name,
+                source: sourceFile.getFilePath(),
+                reason: 'React hook names are not renderable components',
+                stage: 'component-filter',
+            });
             continue;
+        }
         const funcNode = resolveBestFunctionNode(declarations);
         if (!funcNode)
             continue;

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

@@ -1,8 +1,18 @@
-import { Node, Project, type Type } from 'ts-morph';
+import { Node, Project, type SourceFile, type Type } from 'ts-morph';
 export declare function getTsxExtractionContext(filePaths: string[], componentFilePattern: RegExp): {
     componentFiles: string[];
     project: Project;
 } | undefined;
+export declare function extractTsxComponents<T>(filePaths: string[], componentFilePattern: RegExp, extractSourceFile: (sourceFile: SourceFile) => T[]): {
+    componentFiles: string[];
+    project: Project;
+    components: T[];
+    warnings: string[];
+} | undefined;
+export declare function resolveComponentExportName(exportKey: string, declarations: Node[], exported: {
+    has(name: string): boolean;
+}, allowVariableDeclaration?: boolean): string | undefined;
+export declare function isCompositionHookName(name: string): boolean;
 export declare function resolveDefaultExportName(declarations: Node[], exported: {
     has(name: string): boolean;
 }, allowVariableDeclaration?: boolean): string | undefined;

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

@@ -35,6 +35,32 @@ export function getTsxExtractionContext(filePaths, componentFilePattern) {
         project: createTsxProject(getTsxProjectFiles(filePaths)),
     };
 }
+export function extractTsxComponents(filePaths, componentFilePattern, extractSourceFile) {
+    const extractionContext = getTsxExtractionContext(filePaths, componentFilePattern);
+    if (!extractionContext)
+        return undefined;
+    const warnings = [];
+    const components = [];
+    for (const filePath of extractionContext.componentFiles) {
+        try {
+            const sourceFile = extractionContext.project.getSourceFile(filePath);
+            if (!sourceFile)
+                continue;
+            components.push(...extractSourceFile(sourceFile));
+        }
+        catch (e) {
+            warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { ...extractionContext, components, warnings };
+}
+export function resolveComponentExportName(exportKey, declarations, exported, allowVariableDeclaration = false) {
+    const name = exportKey === 'default' ? resolveDefaultExportName(declarations, exported, allowVariableDeclaration) : exportKey;
+    return name && /^[A-Z]/.test(name) ? name : undefined;
+}
+export function isCompositionHookName(name) {
+    return name.startsWith('use');
+}
 export function resolveDefaultExportName(declarations, exported, allowVariableDeclaration = false) {
     const declaration = declarations[0];
     const name = Node.isFunctionDeclaration(declaration)

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

@@ -1,44 +1,35 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { extractAllowedValues, getTypeReferenceName, getTypeTargetDeclarations, getTsxExtractionContext, getValueTargetDeclarations, resolveDefaultExportName, } from './tsx-shared.js';
+import { extractAllowedValues, extractTsxComponents, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, isCompositionHookName, resolveComponentExportName, } from './tsx-shared.js';
 export async function extractVueTsxComponents(filePaths) {
-    const extractionContext = getTsxExtractionContext(filePaths, /\.tsx$/);
+    const exclusions = [];
+    const extractionContext = extractTsxComponents(filePaths, /\.tsx$/, (sourceFile) => extractFromSourceFile(sourceFile, exclusions));
     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 } = extractionContext;
     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))
+        const name = resolveComponentExportName(exportKey, declarations, exported);
+        if (!name)
             continue;
-        if (name.startsWith('use'))
+        if (isCompositionHookName(name)) {
+            exclusions.push({
+                itemType: 'component',
+                name,
+                source: sourceFile.getFilePath(),
+                reason: 'Vue composition hook names are not renderable components',
+                stage: 'component-filter',
+            });
             continue;
+        }
         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.34.5-dev-build-12a524fb.0",
+  "version": "2.34.5-dev-build-5cd8bcd6.0",
   "description": "Component extraction engine for the Contentful Experience Design System SDK",
   "license": "MIT",
   "type": "module",