@contentful/experience-design-system-extraction 2.33.1-dev-build-3d84cf3.0 → 2.33.1-dev-build-c4ed223.0

package/dist/src/extract/resolve-local-module.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveLocalModule(importingFilePath: string, specifier: string, options?: {
+    allowJavaScriptExtensionFallback?: boolean;
+}): string | null;

package/dist/src/extract/resolve-local-module.js

@@ -0,0 +1,26 @@
+import { existsSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export function resolveLocalModule(importingFilePath, specifier, options = {}) {
+    const basePath = resolve(dirname(importingFilePath), specifier);
+    const candidates = [
+        basePath,
+        `${basePath}.js`,
+        `${basePath}.ts`,
+        `${basePath}.mjs`,
+        `${basePath}.cjs`,
+        join(basePath, 'index.js'),
+        join(basePath, 'index.ts'),
+        join(basePath, 'index.mjs'),
+        join(basePath, 'index.cjs'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate) && statSync(candidate).isFile())
+            return candidate;
+    }
+    if (options.allowJavaScriptExtensionFallback && basePath.endsWith('.js')) {
+        const tsPath = `${basePath.slice(0, -'.js'.length)}.ts`;
+        if (existsSync(tsPath) && statSync(tsPath).isFile())
+            return tsPath;
+    }
+    return null;
+}

package/dist/src/extract/resolve-type-property.d.ts

@@ -0,0 +1,16 @@
+import type { Node, Type } from 'ts-morph';
+type TypeProperty = {
+    getName(): string;
+    getValueDeclaration(): Node | undefined;
+    getDeclarations(): Node[];
+    getTypeAtLocation(node: Node): Type;
+    isOptional(): boolean;
+};
+export type ResolvedTypeProperty = {
+    name: string;
+    declaration: Node;
+    typeText: string;
+    required: boolean;
+};
+export declare function resolveTypeProperty(property: TypeProperty): ResolvedTypeProperty | null;
+export {};

package/dist/src/extract/resolve-type-property.js

@@ -0,0 +1,11 @@
+export function resolveTypeProperty(property) {
+    const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
+    if (!declaration)
+        return null;
+    return {
+        name: property.getName(),
+        declaration,
+        typeText: property.getTypeAtLocation(declaration).getText(declaration),
+        required: !property.isOptional(),
+    };
+}

package/dist/src/extract/slot-detection.js

@@ -28,18 +28,21 @@ export const CONTENT_NAME_EXCEPTIONS = new Set([
     'excerpt',
 ]);
 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(' | ');
+}
 /**
  * Checks if a type string represents a ReactNode/ReactElement/JSX.Element type,
  * including unions with null/undefined.
  */
 export function isReactNodeType(typeText) {
-    const normalized = typeText.replace(/\s+/g, ' ').trim();
-    // Strip optional markers and union with null/undefined
-    const stripped = normalized
-        .split('|')
-        .map((part) => part.trim())
-        .filter((part) => part !== 'null' && part !== 'undefined')
-        .join(' | ');
+    const stripped = normalizeReactNodeType(typeText);
     // Check exact match (after stripping null/undefined union members)
     if (REACT_NODE_EXACT_PATTERNS.includes(stripped)) {
         return true;
@@ -55,13 +58,7 @@ export function isReactNodeType(typeText) {
  * Examples: ReactNode[], React.ReactNode[], Array<ReactNode>
  */
 export function isArrayReactNodeType(typeText) {
-    const normalized = typeText.replace(/\s+/g, ' ').trim();
-    // Strip optional markers and union with null/undefined
-    const stripped = normalized
-        .split('|')
-        .map((part) => part.trim())
-        .filter((part) => part !== 'null' && part !== 'undefined')
-        .join(' | ');
+    const stripped = normalizeReactNodeType(typeText);
     // Pattern: ReactNode[] or React.ReactNode[] etc.
     for (const pattern of REACT_NODE_EXACT_PATTERNS) {
         if (stripped === `${pattern}[]`) {

package/dist/src/extract/source-inspection.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { parseImportedNames } from './parse-imported-names.js';
 export const HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON = 'data-fetch-wrapper';
 export const POSSIBLE_DATA_FETCH_WRAPPER_REASON = 'possible-data-fetch-wrapper';
 export const ZERO_SURFACE_RENDERED_UI_REASON = 'zero-surface:rendered-ui';
@@ -13,33 +14,6 @@ const IMPORT_PATTERN = /import\s+(?:type\s+)?(.+?)\s+from\s+['"]([^'"]+)['"]/g;
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function parseImportedNames(importClause) {
-    const trimmed = importClause.trim();
-    if (!trimmed)
-        return [];
-    const names = [];
-    const defaultAndNamed = trimmed.split(',').map((part) => part.trim());
-    for (const part of defaultAndNamed) {
-        if (!part)
-            continue;
-        if (part.startsWith('{') && part.endsWith('}')) {
-            for (const named of part
-                .slice(1, -1)
-                .split(',')
-                .map((item) => item.trim())
-                .filter(Boolean)) {
-                const [local] = named.split(/\s+as\s+/i);
-                if (local)
-                    names.push(local.trim());
-            }
-            continue;
-        }
-        const [local] = part.split(/\s+as\s+/i);
-        if (local)
-            names.push(local.trim());
-    }
-    return names;
-}
 function collectSiblingRendererImports(sourceText) {
     const names = new Set();
     for (const match of sourceText.matchAll(IMPORT_PATTERN)) {

package/dist/src/extract/source-line-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from 'ts-morph';
+import type { RawPropDefinition } from '../types.js';
+export declare function getSourceLineMetadata(declaration: Node | undefined): Pick<RawPropDefinition, 'sourceStartLine' | 'sourceEndLine'>;

package/dist/src/extract/source-line-metadata.js

@@ -0,0 +1,13 @@
+export function getSourceLineMetadata(declaration) {
+    if (!declaration)
+        return {};
+    const lineAwareDeclaration = declaration;
+    if (typeof lineAwareDeclaration.getStartLineNumber !== 'function' ||
+        typeof lineAwareDeclaration.getEndLineNumber !== 'function') {
+        return {};
+    }
+    return {
+        sourceStartLine: lineAwareDeclaration.getStartLineNumber(),
+        sourceEndLine: lineAwareDeclaration.getEndLineNumber(),
+    };
+}

package/dist/src/extract/stencil.js

@@ -1,15 +1,9 @@
 import { Project, Node, SyntaxKind } from 'ts-morph';
-import { getJsxTagNameNode, isIntrinsicJsxElement } from './tsx-shared.js';
+import { getJsxTagNameNode, isIntrinsicJsxElement, kebabToPascal } from './tsx-shared.js';
+import { createSortedExtractionResult, extractProjectSourceFiles } from './file-extraction-workers.js';
 function isStencilFile(sourceFile) {
     return sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === '@stencil/core');
 }
-function kebabToPascal(input) {
-    return input
-        .split('-')
-        .filter(Boolean)
-        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-        .join('');
-}
 function getComponentTag(classDecl) {
     for (const decorator of classDecl.getDecorators()) {
         if (decorator.getName() !== 'Component')
@@ -307,22 +301,12 @@ export async function extractStencilComponents(filePaths) {
     for (const filePath of tsxFiles) {
         project.addSourceFileAtPath(filePath);
     }
-    const warnings = [];
-    const components = [];
-    for (const sourceFile of project.getSourceFiles()) {
-        try {
-            if (!isStencilFile(sourceFile))
-                continue;
-            const extracted = extractFromSourceFile(sourceFile, warnings);
-            components.push(...extracted);
-            detectFunctionalComponents(sourceFile, warnings);
-        }
-        catch (e) {
-            warnings.push(`Failed to extract from ${sourceFile.getFilePath()}: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    return {
-        components: components.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings,
-    };
+    const { items: components, warnings } = extractProjectSourceFiles(project, (sourceFile, sourceWarnings) => {
+        if (!isStencilFile(sourceFile))
+            return [];
+        const extracted = extractFromSourceFile(sourceFile, sourceWarnings);
+        detectFunctionalComponents(sourceFile, sourceWarnings);
+        return extracted;
+    });
+    return createSortedExtractionResult(components, warnings);
 }

package/dist/src/extract/svelte.js

@@ -1,47 +1,24 @@
 import { basename, dirname, resolve, join } from 'node:path';
-import { readFile } from 'node:fs/promises';
-import { existsSync, readFileSync, statSync } from 'node:fs';
+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'));
-    if (svelteFiles.length === 0)
-        return { components: [], warnings: [] };
-    const warnings = [];
-    const components = [];
     const retryContexts = new Map();
-    let filesProcessed = 0;
-    let componentsFound = 0;
-    const queue = [...svelteFiles];
-    async function worker() {
-        while (queue.length > 0) {
-            const filePath = queue.shift();
-            if (!filePath)
-                break;
-            try {
-                const source = await readFile(filePath, 'utf-8');
-                const { component, warnings: fileWarnings, retryContext } = await extractFromSvelteFile(filePath, source);
-                warnings.push(...fileWarnings);
-                if (component) {
-                    components.push(component);
-                    componentsFound++;
-                }
-                if (retryContext)
-                    retryContexts.set(filePath, retryContext);
-            }
-            catch (e) {
-                warnings.push(`${getSvelteComponentName(filePath)}: failed to extract from ${filePath} — ${e instanceof Error ? e.message : String(e)}`);
-            }
-            filesProcessed++;
-            onProgress?.({ filesProcessed, componentsFound });
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(SVELTE_EXTRACT_CONCURRENCY, svelteFiles.length) }, worker));
+    const { items: components, warnings } = await runFileExtractionWorkers(svelteFiles, SVELTE_EXTRACT_CONCURRENCY, 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) => {
+        if (outcome.metadata)
+            retryContexts.set(filePath, outcome.metadata);
+    });
     const finalWarnings = await maybeRunResolveUnreachableRetry(components, warnings, retryContexts, opts);
     resolveAllowedComponents(components);
     return {
@@ -1155,37 +1132,13 @@ async function resolveImportedTypeMembers(typeName, instance, filePath) {
         }
         if (!importedExport)
             continue;
-        const resolvedFile = resolveLocalScriptModule(filePath, specifierValue);
+        const resolvedFile = resolveLocalModule(filePath, specifierValue, { allowJavaScriptExtensionFallback: true });
         if (!resolvedFile)
             continue;
         return readMembersFromExternalFile(resolvedFile, importedExport);
     }
     return null;
 }
-function resolveLocalScriptModule(importingFilePath, specifier) {
-    const basePath = resolve(dirname(importingFilePath), specifier);
-    const candidates = [
-        basePath,
-        `${basePath}.js`,
-        `${basePath}.ts`,
-        `${basePath}.mjs`,
-        `${basePath}.cjs`,
-        join(basePath, 'index.js'),
-        join(basePath, 'index.ts'),
-        join(basePath, 'index.mjs'),
-        join(basePath, 'index.cjs'),
-    ];
-    for (const c of candidates) {
-        if (existsSync(c) && statSync(c).isFile())
-            return c;
-    }
-    if (basePath.endsWith('.js')) {
-        const tsPath = `${basePath.slice(0, -'.js'.length)}.ts`;
-        if (existsSync(tsPath) && statSync(tsPath).isFile())
-            return tsPath;
-    }
-    return null;
-}
 function readMembersFromExternalFile(filePath, exportName) {
     const project = new Project({
         compilerOptions: {

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

@@ -1,4 +1,12 @@
-import { Node, type Type } from 'ts-morph';
+import { Node, Project, type Type } from 'ts-morph';
+export declare function getTsxExtractionContext(filePaths: string[], componentFilePattern: RegExp): {
+    componentFiles: string[];
+    project: Project;
+} | undefined;
+export declare function resolveDefaultExportName(declarations: Node[], exported: {
+    has(name: string): boolean;
+}, allowVariableDeclaration?: boolean): string | undefined;
+export declare function kebabToPascal(input: string): string;
 export declare function extractAllowedValues(type: Type): string[] | undefined;
 /**
  * Custom elements include a hyphen. Lowercase, unqualified tags are therefore

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

@@ -1,11 +1,58 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { Node, SyntaxKind } from 'ts-morph';
+import { Node, Project, SyntaxKind } from 'ts-morph';
 import ts from 'typescript';
 const packageRootByFilePathCache = new Map();
 const workspacePackageManifestCache = new Map();
 const nearestTsConfigPathCache = new Map();
 const tsConfigPathsCache = new Map();
+function createTsxProject(filePaths) {
+    const project = new Project({
+        compilerOptions: {
+            jsx: 1,
+            target: 99,
+            module: 99,
+            moduleResolution: 100,
+            skipLibCheck: true,
+            allowJs: true,
+        },
+        skipAddingFilesFromTsConfig: true,
+    });
+    for (const filePath of filePaths) {
+        project.addSourceFileAtPath(filePath);
+    }
+    return project;
+}
+function getTsxProjectFiles(filePaths) {
+    return filePaths.filter((filePath) => /\.[jt]sx?$/.test(filePath) && !filePath.endsWith('.d.ts'));
+}
+export function getTsxExtractionContext(filePaths, componentFilePattern) {
+    const componentFiles = filePaths.filter((filePath) => componentFilePattern.test(filePath));
+    if (componentFiles.length === 0)
+        return undefined;
+    return {
+        componentFiles,
+        project: createTsxProject(getTsxProjectFiles(filePaths)),
+    };
+}
+export function resolveDefaultExportName(declarations, exported, allowVariableDeclaration = false) {
+    const declaration = declarations[0];
+    const name = Node.isFunctionDeclaration(declaration)
+        ? declaration.getName()
+        : allowVariableDeclaration && Node.isVariableDeclaration(declaration)
+            ? declaration.getName()
+            : undefined;
+    if (!name || !/^[A-Z]/.test(name) || exported.has(name))
+        return undefined;
+    return name;
+}
+export function kebabToPascal(input) {
+    return input
+        .split('-')
+        .filter(Boolean)
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('');
+}
 export function extractAllowedValues(type) {
     if (!type.isUnion())
         return undefined;

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

@@ -1,5 +1,4 @@
 import type { RawComponentDefinition, ExtractionValidationIssue } from '../types.js';
-export type { ExtractionValidationIssue } from '../types.js';
 export declare function validateExtractedComponents(components: RawComponentDefinition[]): RawComponentDefinition[];
 export declare function shouldExcludeDueToValidation(component: RawComponentDefinition): boolean;
 /**
@@ -14,3 +13,7 @@ export declare function formatExclusionWarning(rejected: Array<{
     name: string;
     validationIssues?: ExtractionValidationIssue[];
 }>): string;
+export declare function formatExcludedComponentLines(rejected: Array<{
+    name: string;
+    validationIssues?: ExtractionValidationIssue[];
+}>): string[];

package/dist/src/extract/validate.js

@@ -82,13 +82,18 @@ export function shouldExcludeDueToValidation(component) {
 export function formatExclusionWarning(rejected) {
     if (rejected.length === 0)
         return '';
-    const lines = [`Warning: ${rejected.length} component(s) excluded due to validation errors:`];
-    for (const comp of rejected) {
+    const lines = [
+        `Warning: ${rejected.length} component(s) excluded due to validation errors:`,
+        ...formatExcludedComponentLines(rejected),
+    ];
+    return lines.join('\n') + '\n';
+}
+export function formatExcludedComponentLines(rejected) {
+    return rejected.map((comp) => {
         const codes = (comp.validationIssues ?? [])
             .filter((i) => i.severity === 'error')
             .map((i) => i.code)
             .join(', ');
-        lines.push(`  ✗  ${comp.name}  ${codes}`);
-    }
-    return lines.join('\n') + '\n';
+        return `  ✗  ${comp.name}  ${codes}`;
+    });
 }

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

@@ -1,25 +1,11 @@
-import { Node, Project, SyntaxKind } from 'ts-morph';
-import { extractAllowedValues, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, } from './tsx-shared.js';
+import { Node, SyntaxKind } from 'ts-morph';
+import { extractAllowedValues, getTypeReferenceName, getTypeTargetDeclarations, getTsxExtractionContext, getValueTargetDeclarations, resolveDefaultExportName, } from './tsx-shared.js';
 export async function extractVueTsxComponents(filePaths) {
-    const componentFiles = filePaths.filter((f) => f.endsWith('.tsx'));
-    if (componentFiles.length === 0) {
+    const extractionContext = getTsxExtractionContext(filePaths, /\.tsx$/);
+    if (!extractionContext) {
         return { components: [], warnings: [] };
     }
-    const projectFiles = filePaths.filter((f) => /\.[jt]sx?$/.test(f) && !f.endsWith('.d.ts'));
-    const project = new Project({
-        compilerOptions: {
-            jsx: 1,
-            target: 99,
-            module: 99,
-            moduleResolution: 100,
-            skipLibCheck: true,
-            allowJs: true,
-        },
-        skipAddingFilesFromTsConfig: true,
-    });
-    for (const filePath of projectFiles) {
-        project.addSourceFileAtPath(filePath);
-    }
+    const { componentFiles, project } = extractionContext;
     const warnings = [];
     const components = [];
     for (const filePath of componentFiles) {
@@ -44,13 +30,10 @@ function extractFromSourceFile(sourceFile) {
     for (const [exportKey, declarations] of exported) {
         let name = exportKey;
         if (exportKey === 'default') {
-            const decl = declarations[0];
-            const declName = Node.isFunctionDeclaration(decl) ? decl.getName() : undefined;
-            if (!declName || !/^[A-Z]/.test(declName))
-                continue;
-            if (exported.has(declName))
+            const defaultExportName = resolveDefaultExportName(declarations, exported);
+            if (!defaultExportName)
                 continue;
-            name = declName;
+            name = defaultExportName;
         }
         if (!/^[A-Z]/.test(name))
             continue;
@@ -415,20 +398,22 @@ function extractStringLiteralArrayValues(node) {
     }
     return keys;
 }
+function extractSlotMembers(members, allowMethods) {
+    return members
+        .flatMap((member) => {
+        if (!Node.isPropertySignature(member) && (!allowMethods || !Node.isMethodSignature(member)))
+            return [];
+        const slotName = member.getName();
+        return [{ name: slotName, isDefault: slotName === 'default' }];
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
 function extractVueSlotsFromTypeNode(typeNode, seen) {
     if (!typeNode || seen.has(typeNode))
         return [];
     seen.add(typeNode);
     if (Node.isTypeLiteral(typeNode)) {
-        return typeNode
-            .getMembers()
-            .flatMap((member) => {
-            if (!Node.isPropertySignature(member))
-                return [];
-            const slotName = member.getName();
-            return [{ name: slotName, isDefault: slotName === 'default' }];
-        })
-            .sort((a, b) => a.name.localeCompare(b.name));
+        return extractSlotMembers(typeNode.getMembers(), false);
     }
     if (Node.isTypeReference(typeNode)) {
         for (const declaration of getTypeTargetDeclarations(typeNode.getTypeName(), false)) {
@@ -436,15 +421,7 @@ function extractVueSlotsFromTypeNode(typeNode, seen) {
                 return extractVueSlotsFromTypeNode(declaration.getTypeNode(), seen);
             }
             if (Node.isInterfaceDeclaration(declaration)) {
-                return declaration
-                    .getMembers()
-                    .flatMap((member) => {
-                    if (!Node.isPropertySignature(member) && !Node.isMethodSignature(member))
-                        return [];
-                    const slotName = member.getName();
-                    return [{ name: slotName, isDefault: slotName === 'default' }];
-                })
-                    .sort((a, b) => a.name.localeCompare(b.name));
+                return extractSlotMembers(declaration.getMembers(), true);
             }
         }
     }

package/dist/src/extract/vue.js

@@ -4,6 +4,9 @@ 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';
+import { resolveLocalModule } from './resolve-local-module.js';
+import { resolveTypeProperty } from './resolve-type-property.js';
 // @vue/compiler-core NodeTypes enum values (stable since Vue 3.0)
 const ELEMENT_TYPE = 1;
 const ATTRIBUTE_TYPE = 6;
@@ -20,40 +23,11 @@ const VUE_TYPE_MAP = {
 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'));
-    if (vueFiles.length === 0) {
-        return { components: [], warnings: [] };
-    }
-    const warnings = [];
-    const components = [];
-    let filesProcessed = 0;
-    let componentsFound = 0;
-    const queue = [...vueFiles];
-    async function worker() {
-        while (queue.length > 0) {
-            const filePath = queue.shift();
-            if (!filePath)
-                break;
-            try {
-                const source = await readFile(filePath, 'utf-8');
-                const { component, warnings: fileWarnings } = await extractFromVueSFC(filePath, source);
-                warnings.push(...fileWarnings);
-                if (component) {
-                    components.push(component);
-                    componentsFound++;
-                }
-            }
-            catch (e) {
-                warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
-            }
-            filesProcessed++;
-            onProgress?.({ filesProcessed, componentsFound });
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(VUE_EXTRACT_CONCURRENCY, vueFiles.length) }, worker));
-    return {
-        components: components.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings,
-    };
+    const { items: components, warnings } = await runFileExtractionWorkers(vueFiles, VUE_EXTRACT_CONCURRENCY, 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);
+    return createSortedExtractionResult(components, warnings);
 }
 async function extractFromVueSFC(filePath, source) {
     const { descriptor, errors } = parseSFC(source);
@@ -179,20 +153,19 @@ function extractGenericProps(typeText) {
     const type = typeAlias.getType();
     const props = [];
     for (const property of type.getProperties()) {
-        const name = property.getName();
-        const decl = property.getValueDeclaration() ?? property.getDeclarations()[0];
-        if (!decl)
+        const resolved = resolveTypeProperty(property);
+        if (!resolved)
             continue;
-        const propType = property.getTypeAtLocation(decl);
+        const { name, typeText: resolvedTypeText, required } = resolved;
         // Strip `| undefined` from optional types for clean output
-        let resolvedTypeText = propType.getText(decl);
-        if (property.isOptional()) {
-            resolvedTypeText = resolvedTypeText.replace(/\s*\|\s*undefined$/, '').replace(/^undefined\s*\|\s*/, '');
+        let typeText = resolvedTypeText;
+        if (!required) {
+            typeText = typeText.replace(/\s*\|\s*undefined$/, '').replace(/^undefined\s*\|\s*/, '');
         }
         props.push({
             name,
-            type: resolvedTypeText,
-            required: !property.isOptional(),
+            type: typeText,
+            required,
         });
     }
     return props.sort((a, b) => a.name.localeCompare(b.name));
@@ -203,7 +176,7 @@ function collectSetupImportedObjectRefs(sf, filePath) {
         const specifier = importDecl.getModuleSpecifierValue();
         if (!specifier.startsWith('.'))
             continue;
-        const resolvedImportPath = resolveLocalScriptModule(filePath, specifier);
+        const resolvedImportPath = resolveLocalModule(filePath, specifier);
         if (!resolvedImportPath)
             continue;
         for (const namedImport of importDecl.getNamedImports()) {
@@ -215,26 +188,6 @@ function collectSetupImportedObjectRefs(sf, filePath) {
     }
     return refs;
 }
-function resolveLocalScriptModule(importingFilePath, specifier) {
-    const basePath = resolve(dirname(importingFilePath), specifier);
-    const candidates = [
-        basePath,
-        `${basePath}.js`,
-        `${basePath}.ts`,
-        `${basePath}.mjs`,
-        `${basePath}.cjs`,
-        join(basePath, 'index.js'),
-        join(basePath, 'index.ts'),
-        join(basePath, 'index.mjs'),
-        join(basePath, 'index.cjs'),
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate) && statSync(candidate).isFile()) {
-            return candidate;
-        }
-    }
-    return null;
-}
 async function parseSetupObjectProps(obj, importedObjectRefs, visitedImports) {
     const mergedProps = new Map();
     for (const prop of parseObjectProps(obj)) {