@contentful/experience-design-system-extraction 2.34.5-dev-build-4a4b9e84.0 → 2.34.5-dev-build-9dff4380.0

package/dist/package.json

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

package/dist/src/extract/{adapters/astro/extractor.d.ts → astro.d.ts}

@@ -1,4 +1,4 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ComponentExtractionResult } from '../types.js';
 export declare function extractAstroComponents(filePaths: string[], onProgress?: (p: {
     filesProcessed: number;
     componentsFound: number;

package/dist/src/extract/{adapters/astro/extractor.js → astro.js}

@@ -1,10 +1,9 @@
 import os from 'node:os';
 import { basename } from 'node:path';
 import { Project, Node } from 'ts-morph';
-import { runFileExtractionWorkers } from '../support/file-processing/file-workers.js';
-import { createSortedExtractionResult } from '../support/file-processing/result-normalizer.js';
-import { resolveTypeProperty } from '../support/resolution/type-property.js';
-import { getSourceLineMetadata } from '../support/resolution/source-location.js';
+import { createSortedExtractionResult, runFileExtractionWorkers } from './file-extraction-workers.js';
+import { resolveTypeProperty } from './resolve-type-property.js';
+import { getSourceLineMetadata } from './source-line-metadata.js';
 function extractAllowedValues(typeText) {
     // Check if the type is a union of string literals like 'a' | 'b' | 'c'
     const parts = typeText.split('|').map((p) => p.trim());

package/dist/src/extract/{adapters/support/file-processing/file-workers.d.ts → file-extraction-workers.d.ts}

@@ -1,9 +1,10 @@
+import type { Project, SourceFile } from 'ts-morph';
 export type FileExtractionOutcome<T, M = undefined> = {
     item: T | null;
     warnings?: string[];
     metadata?: M;
 };
-export type FileExtractionProgress = {
+type FileExtractionProgress = {
     filesProcessed: number;
     componentsFound: number;
 };
@@ -11,3 +12,14 @@ export declare function runFileExtractionWorkers<T, M = undefined>(filePaths: st
     items: T[];
     warnings: string[];
 }>;
+export declare function createSortedExtractionResult<T extends {
+    name: string;
+}>(components: T[], warnings: string[]): {
+    components: T[];
+    warnings: string[];
+};
+export declare function extractProjectSourceFiles<T>(project: Project, extractFile: (sourceFile: SourceFile, warnings: string[]) => T[]): {
+    items: T[];
+    warnings: string[];
+};
+export {};

package/dist/src/extract/{adapters/support/file-processing/file-workers.js → file-extraction-workers.js}

@@ -27,3 +27,22 @@ export async function runFileExtractionWorkers(filePaths, concurrency, extractFi
     await Promise.all(Array.from({ length: Math.min(concurrency, filePaths.length) }, worker));
     return { items, warnings };
 }
+export function createSortedExtractionResult(components, warnings) {
+    return {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings,
+    };
+}
+export function extractProjectSourceFiles(project, extractFile) {
+    const warnings = [];
+    const items = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        try {
+            items.push(...extractFile(sourceFile, warnings));
+        }
+        catch (error) {
+            warnings.push(`Failed to extract from ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { items, warnings };
+}

package/dist/src/extract/{policies/quality/authorability.d.ts → non-authorable-filter.d.ts}

@@ -1,4 +1,4 @@
-import type { RawComponentDefinition } from '../../model/component.js';
+import type { RawComponentDefinition } from '../types.js';
 interface NonAuthorableResult {
     skip: boolean;
     reason?: string;

package/dist/src/extract/pipeline.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentExtractionResult, ExtractorOptions } from '../types.js';
+type ExtractProgress = {
+    filesProcessed: number;
+    componentsFound: number;
+};
+export declare function extractComponents(filePaths: string[], onProgress?: (progress: ExtractProgress) => void, opts?: ExtractorOptions): Promise<ComponentExtractionResult>;
+export {};

package/dist/src/extract/{services/component-deduplicator.js → pipeline.js}

@@ -1,3 +1,57 @@
+import { extractStencilComponents } from './stencil.js';
+import { extractReactComponents } from './react.js';
+import { extractVueTsxComponents } from './vue-tsx.js';
+import { extractVueComponents } from './vue.js';
+import { extractAstroComponents } from './astro.js';
+import { extractWebComponentDefinitions } from './web-components.js';
+import { extractSvelteComponents } from './svelte.js';
+const extractors = [
+    {
+        name: 'stencil',
+        fileFilter: (f) => /\.[jt]sx$/.test(f),
+        extract: extractStencilComponents,
+    },
+    {
+        name: 'react',
+        fileFilter: (f) => /\.[jt]sx?$/.test(f) && !f.endsWith('.d.ts'),
+        extract: extractReactComponents,
+    },
+    {
+        name: 'vue-tsx',
+        fileFilter: (f) => /\.[jt]sx?$/.test(f) && !f.endsWith('.d.ts'),
+        extract: extractVueTsxComponents,
+    },
+    {
+        name: 'vue',
+        fileFilter: (f) => f.endsWith('.vue'),
+        extract: extractVueComponents,
+    },
+    {
+        name: 'astro',
+        fileFilter: (f) => f.endsWith('.astro'),
+        extract: extractAstroComponents,
+    },
+    {
+        name: 'web-components',
+        fileFilter: (f) => /\.[jt]s$/.test(f) && !/\.[jt]sx$/.test(f) && !f.endsWith('.d.ts'),
+        extract: extractWebComponentDefinitions,
+    },
+    {
+        name: 'svelte',
+        fileFilter: (f) => {
+            if (!f.endsWith('.svelte'))
+                return false;
+            // SvelteKit route conventions: +page.svelte, +layout.svelte, +error.svelte
+            // are framework-managed entrypoints, not authorable design-system components.
+            // Mirrors how Next.js page.tsx / layout.tsx are filtered in pre-classify.
+            const filename = f.replace(/\\/g, '/').split('/').pop() ?? '';
+            if (/^\+(page|layout|error)\.svelte$/.test(filename))
+                return false;
+            return true;
+        },
+        extract: extractSvelteComponents,
+    },
+];
 function getPathPreferenceScore(filePath) {
     const normalized = filePath.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
@@ -36,8 +90,9 @@ function getScopeInfo(filePath) {
     const normalized = filePath.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
     const rootInfo = getPackageRootInfo(segments);
-    if (!rootInfo)
+    if (!rootInfo) {
         return null;
+    }
     const { rootSegments, relativeSegments } = rootInfo;
     return {
         rootKey: rootSegments.join('/'),
@@ -99,35 +154,44 @@ function isWithinTopLevelFamily(relativeSegments, componentName) {
     if (relativeSegments.length === 1) {
         return new Set([`${componentName}.tsx`, `${componentName}.ts`, `${componentName}.vue`]).has(first);
     }
-    if (first === 'src' && second === 'components' && third === componentName)
+    if (first === 'src' && second === 'components' && third === componentName) {
         return true;
-    if (first === 'components' && second === componentName)
+    }
+    if (first === 'components' && second === componentName) {
         return true;
-    if (first === 'src' && second === componentName)
+    }
+    if (first === 'src' && second === componentName) {
         return true;
-    if (first === componentName)
+    }
+    if (first === componentName) {
         return componentFilenames.has(second) || relativeSegments.length > 2;
+    }
     return false;
 }
 function getFamilyScopeKey(filePath, componentName, topLevelFamiliesByRoot) {
     const normalized = filePath.replace(/\\/g, '/');
     const scopeInfo = getScopeInfo(filePath);
-    if (!scopeInfo)
+    if (!scopeInfo) {
         return normalized;
+    }
     const { rootKey, relativeSegments } = scopeInfo;
     const topLevelFamilies = topLevelFamiliesByRoot.get(rootKey);
     if (topLevelFamilies?.has(componentName) && isWithinTopLevelFamily(relativeSegments, componentName)) {
         return `${rootKey}::${componentName}`;
     }
     const [first, second, third] = relativeSegments;
-    if (first === 'src' && second === 'components' && third)
+    if (first === 'src' && second === 'components' && third) {
         return `${rootKey}/src/components/${third}`;
-    if (first === 'components' && second)
+    }
+    if (first === 'components' && second) {
         return `${rootKey}/components/${second}`;
-    if (first === 'src' && second && relativeSegments.length > 2)
+    }
+    if (first === 'src' && second && relativeSegments.length > 2) {
         return `${rootKey}/src/${second}`;
-    if (first && relativeSegments.length > 1)
+    }
+    if (first && relativeSegments.length > 1) {
         return `${rootKey}/${first}`;
+    }
     return rootKey;
 }
 function choosePreferredComponent(existing, candidate) {
@@ -160,9 +224,53 @@ function choosePreferredComponent(existing, candidate) {
         reason: `kept ${existing.source} over ${candidate.source} by stable first-seen order`,
     };
 }
-export function deduplicateComponents(results) {
-    const allWarnings = [];
+export async function extractComponents(filePaths, onProgress, opts) {
+    const filesByExtractor = new Map();
     const exclusions = [];
+    for (const extractor of extractors) {
+        filesByExtractor.set(extractor, []);
+    }
+    for (const filePath of filePaths) {
+        for (const extractor of extractors) {
+            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();
+    const perExtractorComponents = new Map();
+    let totalFilesProcessed = 0;
+    let totalComponentsFound = 0;
+    const results = await Promise.all(extractors.map(async (extractor) => {
+        const files = filesByExtractor.get(extractor);
+        if (files.length === 0)
+            return { components: [], warnings: [] };
+        perExtractorFiles.set(extractor, 0);
+        perExtractorComponents.set(extractor, 0);
+        const result = await extractor.extract(files, (p) => {
+            const prevFiles = perExtractorFiles.get(extractor) ?? 0;
+            const prevComponents = perExtractorComponents.get(extractor) ?? 0;
+            totalFilesProcessed += p.filesProcessed - prevFiles;
+            totalComponentsFound += p.componentsFound - prevComponents;
+            perExtractorFiles.set(extractor, p.filesProcessed);
+            perExtractorComponents.set(extractor, p.componentsFound);
+            onProgress?.({ filesProcessed: totalFilesProcessed, componentsFound: totalComponentsFound });
+        }, opts);
+        return result;
+    }));
+    const allWarnings = [];
     const componentsByKey = new Map();
     const keysByName = new Map();
     const topLevelFamiliesByRoot = new Map();
@@ -211,8 +319,24 @@ export function deduplicateComponents(results) {
             keysByName.set(component.name, [...existingKeys, identityKey]);
         }
     }
+    const allComponents = [...componentsByKey.values()];
+    const filteredComponents = [];
+    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);
+    }
     return {
-        components: [...componentsByKey.values()].sort((a, b) => a.name.localeCompare(b.name)),
+        components: filteredComponents.sort((a, b) => a.name.localeCompare(b.name)),
         warnings: allWarnings,
         exclusions,
     };

package/dist/src/extract/{adapters/react/extractor.d.ts → react.d.ts}

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../../model/component.js';
+import type { ComponentExtractionResult } from '../types.js';
 export declare function extractReactComponents(filePaths: string[]): Promise<ComponentExtractionResult>;