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

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

@@ -1,192 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,61 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

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

@@ -1,66 +0,0 @@
-import { Project, Node } from 'ts-morph';
-import { resolveTypeProperty } from '../../shared/helpers/resolve-type-symbol.js';
-import { collectSetupImportedObjectRefs, mergeSetupObjectProps } from './extract-vue-setup-object-props.js';
-function extractGenericSetupProps(typeText) {
-    const project = new Project({
-        compilerOptions: { strict: true, target: 99, module: 99 },
-        useInMemoryFileSystem: true,
-        skipAddingFilesFromTsConfig: true,
-    });
-    const sf = project.createSourceFile('__props__.ts', `type __Props__ = ${typeText};`);
-    const typeAlias = sf.getTypeAlias('__Props__');
-    if (!typeAlias)
-        return [];
-    const props = [];
-    for (const property of typeAlias.getType().getProperties()) {
-        const resolved = resolveTypeProperty(property);
-        if (!resolved)
-            continue;
-        let { typeText: resolvedTypeText } = resolved;
-        if (!resolved.required) {
-            resolvedTypeText = resolvedTypeText.replace(/\s*\|\s*undefined$/, '').replace(/^undefined\s*\|\s*/, '');
-        }
-        props.push({
-            name: resolved.name,
-            type: resolvedTypeText,
-            required: resolved.required,
-        });
-    }
-    return props.sort((a, b) => a.name.localeCompare(b.name));
-}
-export async function extractVueSetupProps(filePath, scriptSetupContent) {
-    const project = new Project({
-        compilerOptions: { strict: false, target: 99, module: 99, allowJs: true },
-        useInMemoryFileSystem: true,
-        skipAddingFilesFromTsConfig: true,
-    });
-    const sf = project.createSourceFile('__setup__.ts', scriptSetupContent);
-    let genericTypeText = null;
-    sf.forEachDescendant((node) => {
-        if (genericTypeText !== null)
-            return;
-        if (Node.isCallExpression(node) &&
-            node.getExpression().getText() === 'defineProps' &&
-            node.getTypeArguments().length > 0) {
-            genericTypeText = node.getTypeArguments()[0].getText();
-        }
-    });
-    if (genericTypeText !== null)
-        return extractGenericSetupProps(genericTypeText);
-    const importedObjectRefs = collectSetupImportedObjectRefs(sf, filePath);
-    let objectProps = null;
-    const visitedImports = new Set();
-    for (const node of sf.getDescendants()) {
-        if (objectProps !== null)
-            break;
-        if (Node.isCallExpression(node) &&
-            node.getExpression().getText() === 'defineProps' &&
-            node.getTypeArguments().length === 0) {
-            const args = node.getArguments();
-            if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                objectProps = await mergeSetupObjectProps(args[0], importedObjectRefs, visitedImports);
-            }
-        }
-    }
-    return objectProps;
-}

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

@@ -1,24 +0,0 @@
-import type { RawSlotDefinition } from '../../../types/component.js';
-interface TemplateAttrNode {
-    type: number;
-    name?: string;
-    value?: {
-        content?: string;
-    };
-}
-interface TemplateAstNode {
-    type: number;
-    tag?: string;
-    props?: TemplateAttrNode[];
-    children?: (TemplateAstNode | unknown)[];
-}
-/** Walks the Vue template AST and collects all `<slot>` elements. */
-export declare function extractSlotsFromVueTemplate(ast: TemplateAstNode): RawSlotDefinition[];
-/**
- * Detects slots referenced via `$slots.name` or `$slots['name']` in template or
- * script content that aren't declared as `<slot>` tags.
- */
-export declare function collectRuntimeAccessSlots(source: string): RawSlotDefinition[];
-/** Merges two slot arrays, keeping the first occurrence of each slot name. */
-export declare function mergeVueSlots(base: RawSlotDefinition[], extra: RawSlotDefinition[]): RawSlotDefinition[];
-export {};

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

@@ -1,56 +0,0 @@
-// @vue/compiler-core NodeTypes enum values (stable since Vue 3.0)
-const ELEMENT_TYPE = 1;
-const ATTRIBUTE_TYPE = 6;
-/** Walks the Vue template AST and collects all `<slot>` elements. */
-export function extractSlotsFromVueTemplate(ast) {
-    const slots = [];
-    function walk(node) {
-        if (node.type === ELEMENT_TYPE && node.tag === 'slot') {
-            const nameProp = node.props?.find((p) => p.type === ATTRIBUTE_TYPE && p.name === 'name');
-            const slotName = nameProp?.value?.content ?? 'default';
-            if (!slots.some((s) => s.name === slotName)) {
-                slots.push({ name: slotName, isDefault: slotName === 'default' });
-            }
-        }
-        if (node.children) {
-            for (const child of node.children) {
-                if (typeof child === 'object' && child !== null && 'type' in child) {
-                    walk(child);
-                }
-            }
-        }
-    }
-    walk(ast);
-    return slots;
-}
-/**
- * Detects slots referenced via `$slots.name` or `$slots['name']` in template or
- * script content that aren't declared as `<slot>` tags.
- */
-export function collectRuntimeAccessSlots(source) {
-    const slots = [];
-    const seen = new Set();
-    const dotPattern = /\$slots\.([a-zA-Z_]\w*)/g;
-    const bracketPattern = /\$slots\[['"]([a-zA-Z_][\w-]*)['"]\]/g;
-    for (const pattern of [dotPattern, bracketPattern]) {
-        let match;
-        while ((match = pattern.exec(source)) !== null) {
-            const name = match[1];
-            if (!seen.has(name)) {
-                seen.add(name);
-                slots.push({ name, isDefault: name === 'default' });
-            }
-        }
-    }
-    return slots;
-}
-/** Merges two slot arrays, keeping the first occurrence of each slot name. */
-export function mergeVueSlots(base, extra) {
-    const merged = [...base];
-    for (const slot of extra) {
-        if (!merged.some((s) => s.name === slot.name)) {
-            merged.push(slot);
-        }
-    }
-    return merged;
-}

package/dist/src/extract/framework-adapters/vue/helpers/resolve-vue-component-name.d.ts

@@ -1,2 +0,0 @@
-/** Derives the component name from its .vue file path (uses parent directory name for index.vue files). */
-export declare function resolveVueComponentName(filePath: string): string;

package/dist/src/extract/framework-adapters/vue/helpers/resolve-vue-component-name.js

@@ -1,9 +0,0 @@
-import { basename, dirname } from 'node:path';
-/** Derives the component name from its .vue file path (uses parent directory name for index.vue files). */
-export function resolveVueComponentName(filePath) {
-    const fileName = basename(filePath, '.vue');
-    if (fileName !== 'index') {
-        return fileName;
-    }
-    return basename(dirname(filePath)) || fileName;
-}

package/dist/src/extract/framework-adapters/vue/helpers/resolve-workspace-module.d.ts

@@ -1 +0,0 @@
-export declare function resolveWorkspaceVueImport(specifier: string, importingFilePath: string): string | null;