@contentful/experience-design-system-extraction 2.36.2-dev-build-a6f80ae6.0 → 2.36.2-dev-build-7907fec3.0

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-type-checker.d.ts

@@ -0,0 +1,4 @@
+import { Project } from 'ts-morph';
+import type { AstNode } from '../types/svelte-ast-node.js';
+import type { ResolvedTypeMember } from './extract-svelte-ast-type-members.js';
+export declare function resolveViaTypeChecker(annotation: AstNode, instance: AstNode, moduleScript: AstNode | undefined, filePath: string, source: string, snippetLocals: Set<string>, externalProject?: Project): Promise<ResolvedTypeMember[] | null>;

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-type-checker.js

@@ -0,0 +1,68 @@
+import { Project, ScriptTarget, ModuleKind, ts } from 'ts-morph';
+import { isSnippetTypeText } from './render-svelte-type.js';
+import { getSourceText, getScriptText, extractAllowedValuesFromType, readJsDocFromDeclaration, readDeclaredTypeNodeText, typeRefersToSnippet, } from './extract-svelte-declaration-data.js';
+export async function resolveViaTypeChecker(annotation, instance, moduleScript, filePath, source, snippetLocals, externalProject) {
+    const annotationText = getSourceText(source, annotation);
+    if (!annotationText)
+        return null;
+    const moduleText = getScriptText(source, moduleScript);
+    const instanceText = getScriptText(source, instance);
+    const synthetic = [moduleText, instanceText, `type __SveltePropsT__ = ${annotationText};`].filter(Boolean).join('\n');
+    const project = externalProject ??
+        new Project({
+            compilerOptions: {
+                strict: false,
+                target: ScriptTarget.ESNext,
+                module: ModuleKind.ESNext,
+                allowJs: true,
+                jsx: ts.JsxEmit.Preserve,
+            },
+            useInMemoryFileSystem: false,
+            skipAddingFilesFromTsConfig: true,
+        });
+    const syntheticPath = `${filePath}.__svelte-props__.ts`;
+    let sf;
+    try {
+        sf = project.createSourceFile(syntheticPath, synthetic, {
+            overwrite: true,
+        });
+    }
+    catch {
+        return null;
+    }
+    const alias = sf.getTypeAlias('__SveltePropsT__');
+    if (!alias)
+        return null;
+    const apparent = alias.getType().getApparentType();
+    const properties = apparent.getProperties();
+    if (properties.length === 0)
+        return null;
+    const members = [];
+    for (const symbol of properties) {
+        const name = symbol.getName();
+        const declaration = symbol.getValueDeclaration() ?? symbol.getDeclarations()[0];
+        if (!declaration)
+            continue;
+        const propType = symbol.getTypeAtLocation(declaration);
+        let typeText = propType.getText(declaration);
+        const optional = symbol.isOptional();
+        if (optional)
+            typeText = typeText.replace(/\s*\|\s*undefined$/, '').replace(/^undefined\s*\|\s*/, '');
+        const allowed = extractAllowedValuesFromType(propType);
+        const description = readJsDocFromDeclaration(declaration);
+        const declaredTypeText = readDeclaredTypeNodeText(declaration);
+        const isSnippet = (declaredTypeText !== null && isSnippetTypeText(declaredTypeText, snippetLocals)) ||
+            typeRefersToSnippet(propType) ||
+            isSnippetTypeText(typeText, snippetLocals);
+        members.push({
+            name,
+            optional,
+            typeText,
+            ...(declaredTypeText ? { declaredTypeText } : {}),
+            isSnippet,
+            ...(allowed ? { allowedValues: allowed } : {}),
+            ...(description ? { description } : {}),
+        });
+    }
+    return members;
+}

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-type-members.d.ts

@@ -0,0 +1,6 @@
+import type { AstNode } from '../types/svelte-ast-node.js';
+import { type ResolvedTypeMember } from './extract-svelte-ast-type-members.js';
+export type { ResolvedTypeMember };
+export { readPropertySignature, readMembersFromTypeLiteral, readMembersFromInterfaceOrAlias, } from './extract-svelte-ast-type-members.js';
+export { resolveViaTypeChecker } from './resolve-svelte-type-checker.js';
+export declare function resolveTypeMembers(annotation: AstNode, instance: AstNode, moduleScript: AstNode | undefined, filePath: string, source: string): Promise<ResolvedTypeMember[] | null>;

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-type-members.js

@@ -0,0 +1,30 @@
+import { collectSnippetImportLocals, findLocalTypeDeclaration, declarationHasHeritage, mergeSets, } from './find-svelte-script-declarations.js';
+import { readMembersFromTypeLiteral, readMembersFromInterfaceOrAlias, } from './extract-svelte-ast-type-members.js';
+import { resolveViaTypeChecker } from './resolve-svelte-type-checker.js';
+import { resolveImportedTypeMembers } from './resolve-svelte-external-type-readers.js';
+export { readPropertySignature, readMembersFromTypeLiteral, readMembersFromInterfaceOrAlias, } from './extract-svelte-ast-type-members.js';
+export { resolveViaTypeChecker } from './resolve-svelte-type-checker.js';
+export async function resolveTypeMembers(annotation, instance, moduleScript, filePath, source) {
+    const snippetLocals = mergeSets(collectSnippetImportLocals(instance), moduleScript ? collectSnippetImportLocals(moduleScript) : new Set());
+    if (annotation.type === 'TSTypeLiteral') {
+        return readMembersFromTypeLiteral(annotation, snippetLocals);
+    }
+    if (annotation.type === 'TSTypeReference') {
+        const refName = annotation['typeName']?.['name'] ?? null;
+        if (refName) {
+            const local = findLocalTypeDeclaration(instance, refName, moduleScript);
+            if (local) {
+                const fastPathMembers = readMembersFromInterfaceOrAlias(local, snippetLocals);
+                if (fastPathMembers.length > 0 && !declarationHasHeritage(local))
+                    return fastPathMembers;
+            }
+            else {
+                const imported = (await resolveImportedTypeMembers(refName, instance, filePath)) ??
+                    (moduleScript ? await resolveImportedTypeMembers(refName, moduleScript, filePath) : null);
+                if (imported)
+                    return imported;
+            }
+        }
+    }
+    return resolveViaTypeChecker(annotation, instance, moduleScript, filePath, source, snippetLocals);
+}

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-unresolved-retry.d.ts

@@ -0,0 +1,13 @@
+import type { RawComponentDefinition } from '../../../types/component.js';
+import type { ExtractorOptions } from '../../../types/options.js';
+import type { AstNode } from '../types/svelte-ast-node.js';
+export interface RetryContext {
+    filePath: string;
+    source: string;
+    instance: AstNode;
+    moduleScript: AstNode | undefined;
+    annotation: AstNode;
+    componentName: string;
+}
+export declare function maybeRunResolveUnreachableRetry(components: RawComponentDefinition[], warnings: string[], retryContexts: Map<string, RetryContext>, opts: ExtractorOptions | undefined): Promise<string[]>;
+export declare function collapseUnresolvedTypeWarnings(warnings: string[]): string[];

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-unresolved-retry.js

@@ -0,0 +1,192 @@
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { Project, ScriptTarget, ModuleKind, ts } from 'ts-morph';
+import { computeExtractionScore, deriveNeedsReview, } from '../../../services/quality/helpers/scoring/compute-extraction-score.js';
+import { mergeSlots } from './extract-svelte-template-slots.js';
+import { collectSnippetImportLocals, mergeSets, findLocalTypeDeclaration, collectReferencedTypeNames, collectImportSpecifiersForNames, } from './find-svelte-script-declarations.js';
+import { resolveViaTypeChecker } from './resolve-svelte-type-members.js';
+import { extractFromTypeMembersOnly } from './extract-svelte-props.js';
+import { locateDtsForSpecifier } from './resolve-dts-location.js';
+async function retryComponentWithProject(component, ctx, project, warnings) {
+    const snippetLocals = mergeSets(collectSnippetImportLocals(ctx.instance), ctx.moduleScript ? collectSnippetImportLocals(ctx.moduleScript) : new Set());
+    let members = null;
+    try {
+        members = await resolveViaTypeChecker(ctx.annotation, ctx.instance, ctx.moduleScript, ctx.filePath, ctx.source, snippetLocals, project);
+    }
+    catch {
+        members = null;
+    }
+    if (!members || members.length === 0)
+        return false;
+    const { props, snippetSlots } = extractFromTypeMembersOnly(members);
+    const templateSlots = component.slots.filter((s) => !snippetSlots.some((ss) => ss.name === s.name));
+    const finalSlots = mergeSlots(snippetSlots, templateSlots).slots;
+    const slotNames = new Set(finalSlots.map((s) => s.name));
+    component.props = props.filter((p) => !slotNames.has(p.name));
+    component.slots = finalSlots;
+    const remainingReasons = (component.reviewReasons ?? []).filter((r) => r !== 'props-type-unresolved');
+    const score = computeExtractionScore(component, {
+        additionalIssueCount: remainingReasons.length,
+        additionalReasons: remainingReasons,
+    });
+    component.extractionConfidence = score.confidence;
+    component.reviewReasons = score.reasons;
+    component.needsReview = deriveNeedsReview(score.confidence);
+    const componentName = component.name;
+    const idx = warnings.findIndex((w) => w.startsWith(`${componentName}: declared Props type `) && /resolved to /.test(w));
+    if (idx >= 0)
+        warnings.splice(idx, 1);
+    return true;
+}
+function addImportedDeclarationsToProject(project, ctx) {
+    const importedNames = collectReferencedTypeNames(ctx.annotation);
+    for (const name of [...importedNames]) {
+        const localDecl = findLocalTypeDeclaration(ctx.instance, name, ctx.moduleScript) ??
+            (ctx.moduleScript ? findLocalTypeDeclaration(ctx.moduleScript, name, ctx.instance) : null);
+        if (localDecl) {
+            for (const referenced of collectReferencedTypeNames(localDecl))
+                importedNames.add(referenced);
+        }
+    }
+    if (importedNames.size === 0)
+        return 0;
+    const imports = collectImportSpecifiersForNames(ctx.instance, importedNames);
+    if (ctx.moduleScript) {
+        for (const [k, v] of collectImportSpecifiersForNames(ctx.moduleScript, importedNames))
+            imports.set(k, v);
+    }
+    if (imports.size === 0)
+        return 0;
+    const req = createRequire(ctx.filePath);
+    let added = 0;
+    for (const specifier of imports.values()) {
+        if (specifier.startsWith('.'))
+            continue;
+        const dtsPath = locateDtsForSpecifier(req, specifier, ctx.filePath);
+        if (!dtsPath)
+            continue;
+        try {
+            const sf = project.addSourceFileAtPathIfExists(dtsPath);
+            if (sf)
+                added++;
+        }
+        catch { }
+    }
+    return added;
+}
+export async function maybeRunResolveUnreachableRetry(components, warnings, retryContexts, opts) {
+    const mode = opts?.resolveUnreachable ?? 'auto';
+    if (mode === 'never')
+        return warnings;
+    const isUnresolved = (c) => (c.reviewReasons ?? []).includes('props-type-unresolved') && !!retryContexts.get(c.source);
+    const unresolvedCount = components.filter(isUnresolved).length;
+    if (unresolvedCount === 0)
+        return warnings;
+    if (mode === 'auto') {
+        const ratio = unresolvedCount / components.length;
+        if (ratio < 0.2)
+            return warnings;
+    }
+    const projectRoot = opts?.projectRoot;
+    let project = null;
+    let tsconfigPath = null;
+    if (projectRoot) {
+        tsconfigPath = findNearestTsconfig(projectRoot);
+    }
+    if (tsconfigPath) {
+        try {
+            project = new Project({
+                tsConfigFilePath: tsconfigPath,
+                skipAddingFilesFromTsConfig: false,
+                compilerOptions: {
+                    allowJs: true,
+                    jsx: ts.JsxEmit.Preserve,
+                },
+            });
+        }
+        catch {
+            project = null;
+        }
+    }
+    let recoveredViaTsconfig = 0;
+    if (project) {
+        for (const component of components) {
+            if (!isUnresolved(component))
+                continue;
+            const ctx = retryContexts.get(component.source);
+            if (!ctx)
+                continue;
+            const recovered = await retryComponentWithProject(component, ctx, project, warnings);
+            if (recovered)
+                recoveredViaTsconfig++;
+        }
+    }
+    let recoveredViaNodeModules = 0;
+    const stillUnresolved = components.filter(isUnresolved);
+    if (stillUnresolved.length > 0) {
+        if (!project) {
+            project = new Project({
+                compilerOptions: {
+                    strict: false,
+                    target: ScriptTarget.ESNext,
+                    module: ModuleKind.ESNext,
+                    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                    allowJs: true,
+                    jsx: ts.JsxEmit.Preserve,
+                },
+                useInMemoryFileSystem: false,
+                skipAddingFilesFromTsConfig: true,
+            });
+        }
+        for (const component of stillUnresolved) {
+            const ctx = retryContexts.get(component.source);
+            if (!ctx)
+                continue;
+            const added = addImportedDeclarationsToProject(project, ctx);
+            if (added === 0)
+                continue;
+            const recovered = await retryComponentWithProject(component, ctx, project, warnings);
+            if (recovered)
+                recoveredViaNodeModules++;
+        }
+    }
+    const didMeaningfulWork = !!tsconfigPath || recoveredViaNodeModules > 0;
+    if (didMeaningfulWork) {
+        const remaining = components.filter(isUnresolved).length;
+        const parts = [];
+        if (tsconfigPath) {
+            parts.push(`tsconfig at ${tsconfigPath} recovered ${recoveredViaTsconfig} component(s)`);
+        }
+        parts.push(`node_modules pass recovered ${recoveredViaNodeModules} more`);
+        parts.push(`${remaining} component(s) remain unresolved`);
+        warnings.push(`Unresolved-type retry pass (mode=${mode}): ${parts.join('; ')}.`);
+    }
+    return warnings;
+}
+function findNearestTsconfig(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 16; i++) {
+        const candidate = join(dir, 'tsconfig.json');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (!parent || parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+export function collapseUnresolvedTypeWarnings(warnings) {
+    const isUnresolvedWarning = (w) => /declared Props type .* resolved to/.test(w);
+    const unresolvedCount = warnings.filter(isUnresolvedWarning).length;
+    if (unresolvedCount < 3)
+        return warnings;
+    const others = warnings.filter((w) => !isUnresolvedWarning(w));
+    const summary = `Unresolved component types: ${unresolvedCount} components have a declared Props type the parser couldn't fully resolve — ` +
+        `most often a cross-package extends pattern (e.g. an interface that extends a type from a node_modules package). ` +
+        `Each affected component is flagged with reviewReasons: ['props-type-unresolved'] and needsReview = true; ` +
+        `select one in the TUI to drill in. ` +
+        `See https://github.com/contentful/experience-design-system-sdk-public/pull/44 for context and partner workarounds.`;
+    return [summary, ...others];
+}

package/dist/src/extract/framework-adapters/svelte/types/svelte-ast-node.d.ts

@@ -0,0 +1,12 @@
+export interface AstNode {
+    type: string;
+    loc?: {
+        start?: {
+            line?: number;
+        };
+        end?: {
+            line?: number;
+        };
+    };
+    [key: string]: unknown;
+}

package/dist/src/extract/framework-adapters/svelte/types/svelte-ast-node.js

@@ -0,0 +1 @@
+export {};

package/dist/src/extract/{vue.d.ts → framework-adapters/vue/extractor.d.ts}

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

package/dist/src/extract/framework-adapters/vue/extractor.js

@@ -0,0 +1,61 @@
+import os from 'node:os';
+import { runFileExtractionWorkers } from '../shared/helpers/file-processing/file-workers.js';
+import { createSortedExtractionResult } from '../shared/helpers/file-processing/result-normalizer.js';
+import { parse as parseSFC } from '@vue/compiler-sfc';
+import { resolveVueComponentName } from './helpers/resolve-vue-component-name.js';
+import { extractSlotsFromVueTemplate, collectRuntimeAccessSlots, mergeVueSlots } from './helpers/extract-vue-slots.js';
+import { extractVueSetupProps } from './helpers/extract-vue-setup-props.js';
+import { extractVueOptionsProps } from './helpers/extract-vue-options-props.js';
+export async function extractVueComponents(filePaths, onProgress) {
+    const vueFiles = filePaths.filter((f) => f.endsWith('.vue'));
+    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);
+    return createSortedExtractionResult(components, warnings);
+}
+async function extractFromVueSFC(filePath, source) {
+    const { descriptor, errors } = parseSFC(source);
+    const fileWarnings = errors.map((e) => `Parse error in ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+    const name = resolveVueComponentName(filePath);
+    let props = [];
+    const setupProps = descriptor.scriptSetup
+        ? await extractVueSetupProps(filePath, descriptor.scriptSetup.content)
+        : null;
+    if (setupProps !== null) {
+        props = setupProps;
+    }
+    else if (descriptor.script) {
+        return extractOptionsApiComponent(filePath, descriptor.script.content, fileWarnings, name, descriptor.template?.ast, source);
+    }
+    const templateSlots = descriptor.template?.ast ? extractSlotsFromVueTemplate(descriptor.template.ast) : [];
+    const slots = mergeVueSlots(templateSlots, collectRuntimeAccessSlots(source));
+    return {
+        component: {
+            name,
+            source: filePath,
+            sourcePath: filePath,
+            framework: 'vue',
+            props,
+            slots,
+        },
+        warnings: fileWarnings,
+    };
+}
+async function extractOptionsApiComponent(filePath, scriptContent, fileWarnings, name, templateAst, sfcSource) {
+    const props = await extractVueOptionsProps(filePath, scriptContent);
+    const templateSlots = templateAst ? extractSlotsFromVueTemplate(templateAst) : [];
+    const runtimeSlots = sfcSource ? collectRuntimeAccessSlots(sfcSource) : [];
+    const slots = mergeVueSlots(templateSlots, runtimeSlots);
+    return {
+        component: {
+            name,
+            source: filePath,
+            sourcePath: filePath,
+            framework: 'vue',
+            props,
+            slots,
+        },
+        warnings: fileWarnings,
+    };
+}

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-object-props.d.ts

@@ -0,0 +1,3 @@
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function isPublicVuePropName(name: string): boolean;
+export declare function parseVueObjectProps(obj: import('ts-morph').ObjectLiteralExpression): RawPropDefinition[];

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-object-props.js

@@ -0,0 +1,67 @@
+import { Node } from 'ts-morph';
+const VUE_TYPE_MAP = {
+    String: 'string',
+    Number: 'number',
+    Boolean: 'boolean',
+    Array: 'any[]',
+    Object: 'object',
+    Function: 'function',
+    Date: 'Date',
+    Symbol: 'symbol',
+};
+export function isPublicVuePropName(name) {
+    return !/^[_$]/.test(name);
+}
+export function parseVueObjectProps(obj) {
+    if (!Node.isObjectLiteralExpression(obj))
+        return [];
+    const result = [];
+    for (const prop of obj.getProperties()) {
+        if (!Node.isPropertyAssignment(prop))
+            continue;
+        const name = prop.getName();
+        if (!isPublicVuePropName(name))
+            continue;
+        const init = prop.getInitializer();
+        if (!init || !Node.isObjectLiteralExpression(init)) {
+            result.push({
+                name,
+                type: VUE_TYPE_MAP[init?.getText() ?? ''] ?? 'any',
+                required: false,
+                sourceStartLine: prop.getStartLineNumber(),
+                sourceEndLine: prop.getEndLineNumber(),
+            });
+            continue;
+        }
+        const typeProp = init.getProperty('type');
+        const requiredProp = init.getProperty('required');
+        const defaultProp = init.getProperty('default');
+        let type = 'any';
+        if (typeProp && Node.isPropertyAssignment(typeProp)) {
+            const typeInit = typeProp.getInitializer();
+            if (typeInit)
+                type = VUE_TYPE_MAP[typeInit.getText()] ?? 'any';
+        }
+        let required = false;
+        if (requiredProp && Node.isPropertyAssignment(requiredProp)) {
+            const reqInit = requiredProp.getInitializer();
+            if (reqInit)
+                required = reqInit.getText() === 'true';
+        }
+        let defaultValue;
+        if (defaultProp && Node.isPropertyAssignment(defaultProp)) {
+            const defInit = defaultProp.getInitializer();
+            if (defInit)
+                defaultValue = defInit.getText().replace(/^['"]|['"]$/g, '');
+        }
+        result.push({
+            name,
+            type,
+            required,
+            ...(defaultValue !== undefined && { defaultValue }),
+            sourceStartLine: prop.getStartLineNumber(),
+            sourceEndLine: prop.getEndLineNumber(),
+        });
+    }
+    return result;
+}

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-options-props.d.ts

@@ -0,0 +1,4 @@
+import type { RawPropDefinition } from '../../../types/component.js';
+export { isPublicVuePropName, parseVueObjectProps } from './extract-vue-object-props.js';
+export declare function extractVueOptionsProps(filePath: string, scriptContent: string, visited?: Set<string>): Promise<RawPropDefinition[]>;
+export declare function extractInheritedVueProps(filePath: string, visited: Set<string>): Promise<RawPropDefinition[]>;

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-options-props.js

@@ -0,0 +1,72 @@
+import { resolve, dirname } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { parse as parseSFC } from '@vue/compiler-sfc';
+import { Node, Project } from 'ts-morph';
+import { resolveWorkspaceVueImport } from './resolve-workspace-module.js';
+import { parseVueObjectProps } from './extract-vue-object-props.js';
+export { isPublicVuePropName, parseVueObjectProps } from './extract-vue-object-props.js';
+export async function extractVueOptionsProps(filePath, scriptContent, visited = new Set()) {
+    const resolvedFilePath = resolve(filePath);
+    if (visited.has(resolvedFilePath))
+        return [];
+    visited.add(resolvedFilePath);
+    const project = new Project({
+        compilerOptions: { strict: false, target: 99, module: 99, allowJs: true },
+        useInMemoryFileSystem: true,
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sf = project.createSourceFile('__options__.ts', scriptContent);
+    const localImports = new Map();
+    for (const importDecl of sf.getImportDeclarations()) {
+        const specifier = importDecl.getModuleSpecifierValue();
+        const defaultImport = importDecl.getDefaultImport();
+        if (!defaultImport)
+            continue;
+        if (specifier.startsWith('.')) {
+            if (!specifier.endsWith('.vue'))
+                continue;
+            localImports.set(defaultImport.getText(), resolve(dirname(resolvedFilePath), specifier));
+        }
+        else {
+            const resolvedVuePath = resolveWorkspaceVueImport(specifier, resolvedFilePath);
+            if (resolvedVuePath)
+                localImports.set(defaultImport.getText(), resolvedVuePath);
+        }
+    }
+    for (const node of sf.getDescendants()) {
+        if (!Node.isExportAssignment(node))
+            continue;
+        const expr = node.getExpression();
+        if (!Node.isObjectLiteralExpression(expr))
+            continue;
+        const mergedProps = new Map();
+        const extendsProp = expr.getProperty('extends');
+        if (extendsProp && Node.isPropertyAssignment(extendsProp)) {
+            const extendsInit = extendsProp.getInitializer();
+            if (extendsInit && Node.isIdentifier(extendsInit)) {
+                const extendsPath = localImports.get(extendsInit.getText());
+                if (extendsPath) {
+                    for (const prop of await extractInheritedVueProps(extendsPath, visited))
+                        mergedProps.set(prop.name, prop);
+                }
+            }
+        }
+        const propsProp = expr.getProperty('props');
+        if (!propsProp || !Node.isPropertyAssignment(propsProp))
+            return [...mergedProps.values()].sort((a, b) => a.name.localeCompare(b.name));
+        const propsInit = propsProp.getInitializer();
+        if (!propsInit || !Node.isObjectLiteralExpression(propsInit))
+            return [...mergedProps.values()].sort((a, b) => a.name.localeCompare(b.name));
+        for (const prop of parseVueObjectProps(propsInit))
+            mergedProps.set(prop.name, prop);
+        return [...mergedProps.values()].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    return [];
+}
+export async function extractInheritedVueProps(filePath, visited) {
+    const source = await readFile(filePath, 'utf-8');
+    const { descriptor } = parseSFC(source);
+    if (!descriptor.script)
+        return [];
+    return extractVueOptionsProps(filePath, descriptor.script.content, visited);
+}

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-setup-object-props.d.ts

@@ -0,0 +1,8 @@
+import type { RawPropDefinition } from '../../../types/component.js';
+type SetupImportedObjectRef = {
+    filePath: string;
+    exportName: string;
+};
+export declare function collectSetupImportedObjectRefs(sf: import('ts-morph').SourceFile, filePath: string): Map<string, SetupImportedObjectRef>;
+export declare function mergeSetupObjectProps(obj: import('ts-morph').ObjectLiteralExpression, importedObjectRefs: Map<string, SetupImportedObjectRef>, visitedImports: Set<string>): Promise<RawPropDefinition[]>;
+export {};

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-setup-object-props.js

@@ -0,0 +1,64 @@
+import { readFile } from 'node:fs/promises';
+import { Project, Node } from 'ts-morph';
+import { resolveLocalModule } from '../../shared/helpers/resolve-import-file-path.js';
+import { parseVueObjectProps } from './extract-vue-object-props.js';
+export function collectSetupImportedObjectRefs(sf, filePath) {
+    const refs = new Map();
+    for (const importDecl of sf.getImportDeclarations()) {
+        const specifier = importDecl.getModuleSpecifierValue();
+        if (!specifier.startsWith('.'))
+            continue;
+        const resolvedImportPath = resolveLocalModule(filePath, specifier);
+        if (!resolvedImportPath)
+            continue;
+        for (const namedImport of importDecl.getNamedImports()) {
+            refs.set(namedImport.getAliasNode()?.getText() ?? namedImport.getName(), {
+                filePath: resolvedImportPath,
+                exportName: namedImport.getName(),
+            });
+        }
+    }
+    return refs;
+}
+async function extractImportedObjectExportProps(importedRef, visitedImports) {
+    const visitKey = `${importedRef.filePath}:${importedRef.exportName}`;
+    if (visitedImports.has(visitKey))
+        return [];
+    visitedImports.add(visitKey);
+    const source = await readFile(importedRef.filePath, 'utf-8');
+    const project = new Project({
+        compilerOptions: { strict: false, target: 99, module: 99, allowJs: true },
+        useInMemoryFileSystem: true,
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sf = project.createSourceFile('__imported_object__.ts', source);
+    for (const declaration of sf.getVariableDeclarations()) {
+        if (declaration.getName() !== importedRef.exportName)
+            continue;
+        const initializer = declaration.getInitializer();
+        if (!initializer || !Node.isObjectLiteralExpression(initializer))
+            continue;
+        return parseVueObjectProps(initializer);
+    }
+    return [];
+}
+export async function mergeSetupObjectProps(obj, importedObjectRefs, visitedImports) {
+    const mergedProps = new Map();
+    for (const prop of parseVueObjectProps(obj))
+        mergedProps.set(prop.name, prop);
+    for (const prop of obj.getProperties()) {
+        if (!Node.isSpreadAssignment(prop))
+            continue;
+        const expression = prop.getExpression();
+        if (!Node.isIdentifier(expression))
+            continue;
+        const importedRef = importedObjectRefs.get(expression.getText());
+        if (!importedRef)
+            continue;
+        for (const importedProp of await extractImportedObjectExportProps(importedRef, visitedImports)) {
+            if (!mergedProps.has(importedProp.name))
+                mergedProps.set(importedProp.name, importedProp);
+        }
+    }
+    return [...mergedProps.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/extract/framework-adapters/vue/helpers/extract-vue-setup-props.d.ts

@@ -0,0 +1,2 @@
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractVueSetupProps(filePath: string, scriptSetupContent: string): Promise<RawPropDefinition[] | null>;