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

package/dist/src/extract/framework-adapters/stencil/helpers/stencil-prop-helpers.d.ts

@@ -0,0 +1,5 @@
+import { type ClassDeclaration } from 'ts-morph';
+/** Parses string literal union type text and returns the sorted values, or undefined if not a literal union. */
+export declare function parseAllowedValues(typeText: string): string[] | undefined;
+/** Finds @Prop-decorated properties that are forwarded directly to intrinsic DOM attributes. */
+export declare function collectDomAttributePropNames(classDecl: ClassDeclaration, propNames: Set<string>): Set<string>;

package/dist/src/extract/framework-adapters/stencil/helpers/stencil-prop-helpers.js

@@ -0,0 +1,39 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getJsxTagNameNode, isIntrinsicJsxElement } from '../../shared/helpers/tsx-shared.js';
+/** Parses string literal union type text and returns the sorted values, or undefined if not a literal union. */
+export function parseAllowedValues(typeText) {
+    const literalPattern = /^'[^']*'(?:\s*\|\s*'[^']*')+$/;
+    if (!literalPattern.test(typeText.trim()))
+        return undefined;
+    const values = typeText
+        .split('|')
+        .map((v) => v.trim().replace(/^'|'$/g, ''))
+        .filter(Boolean)
+        .sort();
+    return values.length >= 2 ? values : undefined;
+}
+/** Finds @Prop-decorated properties that are forwarded directly to intrinsic DOM attributes. */
+export function collectDomAttributePropNames(classDecl, propNames) {
+    const domAttributeProps = new Set();
+    const renderMethod = classDecl.getMethod('render');
+    if (!renderMethod)
+        return domAttributeProps;
+    for (const attribute of renderMethod.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+        const tagName = getJsxTagNameNode(attribute)?.getText();
+        const attributeName = attribute.getNameNode().getText();
+        if (!tagName || !propNames.has(attributeName) || !isIntrinsicJsxElement(tagName))
+            continue;
+        const initializer = attribute.getInitializer();
+        if (!initializer || !Node.isJsxExpression(initializer))
+            continue;
+        const expression = initializer.getExpression();
+        if (!expression || !Node.isPropertyAccessExpression(expression))
+            continue;
+        if (!Node.isThisExpression(expression.getExpression()))
+            continue;
+        if (expression.getName() !== attributeName)
+            continue;
+        domAttributeProps.add(attributeName);
+    }
+    return domAttributeProps;
+}

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

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

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

@@ -0,0 +1,27 @@
+import os from 'node:os';
+import { runFileExtractionWorkers } from '../shared/helpers/file-processing/file-workers.js';
+import { getSvelteComponentName } from './helpers/get-svelte-component-name.js';
+import { maybeRunResolveUnreachableRetry, collapseUnresolvedTypeWarnings, } from './helpers/resolve-svelte-unresolved-retry.js';
+import { resolveAllowedComponents } from './helpers/resolve-svelte-allowed-components.js';
+import { extractFromSvelteFile } from './helpers/extract-from-svelte-file.js';
+export async function extractSvelteComponents(filePaths, onProgress, opts) {
+    const svelteFiles = filePaths.filter((f) => f.endsWith('.svelte'));
+    const retryContexts = new Map();
+    const { items: components, warnings } = await runFileExtractionWorkers(svelteFiles, os.cpus().length, 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 {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings: collapseUnresolvedTypeWarnings(finalWarnings),
+    };
+}

package/dist/src/extract/framework-adapters/svelte/helpers/classify-svelte-props-annotation.d.ts

@@ -0,0 +1,6 @@
+import type { AstNode } from '../types/svelte-ast-node.js';
+import type { ResolvedTypeMember } from './resolve-svelte-type-members.js';
+export declare function formatAnnotation(annotation: AstNode | undefined): string;
+export declare function classifyUnresolved(annotation: AstNode | undefined, members: ResolvedTypeMember[] | null, instance: AstNode, moduleScript: AstNode | undefined): 'empty' | 'partial-heritage' | null;
+export declare function getPropsTypeName(propsCall: AstNode): string | undefined;
+export declare function getRetryAnnotation(propsCall: AstNode): AstNode | undefined;

package/dist/src/extract/framework-adapters/svelte/helpers/classify-svelte-props-annotation.js

@@ -0,0 +1,51 @@
+import { findLocalTypeDeclaration, declarationHasHeritage } from './find-svelte-script-declarations.js';
+export function formatAnnotation(annotation) {
+    if (!annotation)
+        return '<unknown>';
+    if (annotation.type === 'TSTypeReference') {
+        const name = annotation['typeName']?.['name'] ?? null;
+        return name ? `'${name}'` : '<unnamed reference>';
+    }
+    if (annotation.type === 'TSIntersectionType')
+        return '<intersection>';
+    if (annotation.type === 'TSUnionType')
+        return '<union>';
+    if (annotation.type === 'TSTypeLiteral')
+        return '<inline literal>';
+    return `<${annotation.type}>`;
+}
+export function classifyUnresolved(annotation, members, instance, moduleScript) {
+    if (!annotation)
+        return null;
+    if (annotation.type === 'TSTypeLiteral') {
+        const litMembers = annotation['members'] ?? [];
+        if (litMembers.length === 0)
+            return null;
+    }
+    if (members === null || members.length === 0)
+        return 'empty';
+    if (annotation.type === 'TSTypeReference') {
+        const refName = annotation['typeName']?.['name'] ?? null;
+        if (refName) {
+            const decl = findLocalTypeDeclaration(instance, refName, moduleScript);
+            if (decl && declarationHasHeritage(decl) && members.every((m) => m.isSnippet)) {
+                return 'partial-heritage';
+            }
+        }
+    }
+    return null;
+}
+export function getPropsTypeName(propsCall) {
+    const id = propsCall['id'];
+    const annotation = id?.['typeAnnotation']?.['typeAnnotation'];
+    if (annotation?.type === 'TSTypeReference') {
+        const tn = annotation['typeName']?.['name'];
+        if (tn && /^[A-Za-z_$][\w$]*$/.test(tn))
+            return tn;
+    }
+    return undefined;
+}
+export function getRetryAnnotation(propsCall) {
+    const id = propsCall['id'];
+    return id?.['typeAnnotation']?.['typeAnnotation'];
+}

package/dist/src/extract/framework-adapters/svelte/helpers/collect-svelte-type-references.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types/svelte-ast-node.js';
+export declare function collectReferencedTypeNames(node: AstNode): Set<string>;
+export declare function collectImportSpecifiersForNames(script: AstNode, names: Set<string>): Map<string, string>;

package/dist/src/extract/framework-adapters/svelte/helpers/collect-svelte-type-references.js

@@ -0,0 +1,52 @@
+export function collectReferencedTypeNames(node) {
+    const names = new Set();
+    walk(node);
+    return names;
+    function walk(n) {
+        if (!n || typeof n !== 'object')
+            return;
+        if (n.type === 'TSTypeReference') {
+            const tn = n['typeName']?.['name'];
+            if (tn)
+                names.add(tn);
+        }
+        if (n.type === 'TSExpressionWithTypeArguments') {
+            const exprName = n['expression']?.['name'];
+            if (exprName)
+                names.add(exprName);
+        }
+        for (const value of Object.values(n)) {
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    if (v && typeof v === 'object')
+                        walk(v);
+                }
+            }
+            else if (value && typeof value === 'object' && value.type) {
+                walk(value);
+            }
+        }
+    }
+}
+export function collectImportSpecifiersForNames(script, names) {
+    const out = new Map();
+    const body = script['content']?.['body'];
+    if (!body)
+        return out;
+    for (const stmt of body) {
+        if (stmt.type !== 'ImportDeclaration')
+            continue;
+        const specifierValue = stmt['source']?.['value'];
+        if (!specifierValue)
+            continue;
+        const specifiers = stmt['specifiers'] ?? [];
+        for (const spec of specifiers) {
+            if (spec.type !== 'ImportSpecifier' && spec.type !== 'ImportDefaultSpecifier')
+                continue;
+            const localName = spec['local']?.['name'];
+            if (localName && names.has(localName))
+                out.set(localName, specifierValue);
+        }
+    }
+    return out;
+}

package/dist/src/extract/framework-adapters/svelte/helpers/extract-from-svelte-file.d.ts

@@ -0,0 +1,7 @@
+import type { RawComponentDefinition } from '../../../types/component.js';
+import type { RetryContext } from './resolve-svelte-unresolved-retry.js';
+export declare function extractFromSvelteFile(filePath: string, source: string): Promise<{
+    component: RawComponentDefinition | null;
+    warnings: string[];
+    retryContext?: RetryContext;
+}>;

package/dist/src/extract/framework-adapters/svelte/helpers/extract-from-svelte-file.js

@@ -0,0 +1,90 @@
+import { parse as parseSvelte } from 'svelte/compiler';
+import { computeExtractionScore, deriveNeedsReview, } from '../../../services/quality/helpers/scoring/compute-extraction-score.js';
+import { getSvelteComponentName } from './get-svelte-component-name.js';
+import { extractTemplateSlots, mergeSlots } from './extract-svelte-template-slots.js';
+import { hasV4ExportLetProps, findPropsCall, collectSnippetImportLocals } from './find-svelte-script-declarations.js';
+import { extractPropsFromCall, getPropsTypeName, getRetryAnnotation } from './extract-svelte-props.js';
+export async function extractFromSvelteFile(filePath, source) {
+    const warnings = [];
+    const name = getSvelteComponentName(filePath);
+    let ast;
+    try {
+        ast = parseSvelte(source, { modern: true });
+    }
+    catch (e) {
+        return {
+            component: null,
+            warnings: [`${name}: parse error in ${filePath}: ${e instanceof Error ? e.message : String(e)}`],
+        };
+    }
+    const instance = ast['instance'];
+    const moduleScript = ast['module'];
+    const fragment = ast['fragment'];
+    if (instance && hasV4ExportLetProps(instance)) {
+        warnings.push(`${name}: Svelte 4 export let syntax not yet supported (${filePath}); see INTEG-4267 for v5-only scope and follow-up`);
+        return { component: null, warnings };
+    }
+    const propsCall = instance ? findPropsCall(instance) : null;
+    const snippetLocals = instance ? collectSnippetImportLocals(instance) : new Set();
+    let props = [];
+    let propNamesTreatedAsSnippet = new Set();
+    let snippetSlotsFromProps = [];
+    const extractionReasons = [];
+    if (propsCall) {
+        const result = await extractPropsFromCall({
+            propsCall,
+            instance: instance,
+            moduleScript,
+            filePath,
+            componentName: name,
+            source,
+            snippetLocals,
+        });
+        props = result.props;
+        propNamesTreatedAsSnippet = result.snippetNames;
+        snippetSlotsFromProps = result.snippetSlots;
+        warnings.push(...result.warnings);
+        if (result.additionalReasons)
+            extractionReasons.push(...result.additionalReasons);
+    }
+    else if (!instance) {
+        warnings.push(`${name}: no instance script block (${filePath}); no props extracted`);
+    }
+    const templateSlots = fragment ? extractTemplateSlots(fragment) : [];
+    const { slots, mixedWarning } = mergeSlots(snippetSlotsFromProps, templateSlots);
+    if (mixedWarning) {
+        warnings.push(`${name}: mixed Snippet and <slot> usage detected (${filePath}); preferring Snippet entries`);
+    }
+    const propsTypeNameCapture = propsCall ? getPropsTypeName(propsCall) : undefined;
+    const component = {
+        name,
+        source: filePath,
+        framework: 'svelte',
+        props,
+        slots,
+        ...(propsTypeNameCapture ? { _propsTypeName: propsTypeNameCapture } : {}),
+    };
+    const score = computeExtractionScore(component, {
+        additionalIssueCount: extractionReasons.length,
+        additionalReasons: extractionReasons,
+    });
+    component.extractionConfidence = score.confidence;
+    component.reviewReasons = score.reasons;
+    component.needsReview = deriveNeedsReview(score.confidence) || extractionReasons.includes('props-type-unresolved');
+    void propNamesTreatedAsSnippet;
+    let retryContext;
+    if (extractionReasons.includes('props-type-unresolved') && propsCall && instance) {
+        const annotation = getRetryAnnotation(propsCall);
+        if (annotation) {
+            retryContext = {
+                filePath,
+                source,
+                instance,
+                moduleScript,
+                annotation,
+                componentName: name,
+            };
+        }
+    }
+    return { component, warnings, ...(retryContext ? { retryContext } : {}) };
+}

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

@@ -0,0 +1,15 @@
+import type { AstNode } from '../types/svelte-ast-node.js';
+export interface ResolvedTypeMember {
+    name: string;
+    optional: boolean;
+    typeText: string;
+    declaredTypeText?: string;
+    isSnippet: boolean;
+    allowedValues?: string[];
+    description?: string;
+    line?: number;
+    endLine?: number;
+}
+export declare function readPropertySignature(member: AstNode, snippetLocals: Set<string>): ResolvedTypeMember | null;
+export declare function readMembersFromTypeLiteral(literal: AstNode, snippetLocals: Set<string>): ResolvedTypeMember[];
+export declare function readMembersFromInterfaceOrAlias(decl: AstNode, snippetLocals: Set<string>): ResolvedTypeMember[];

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

@@ -0,0 +1,46 @@
+import { isSnippetType, renderType, collectStringLiteralUnion, extractJsdocText } from './render-svelte-type.js';
+export function readPropertySignature(member, snippetLocals) {
+    if (member.type !== 'TSPropertySignature')
+        return null;
+    const key = member['key'];
+    const name = key?.['name'] ?? null;
+    if (!name)
+        return null;
+    const optional = !!member['optional'];
+    const typeNode = member['typeAnnotation']?.['typeAnnotation'];
+    const typeText = renderType(typeNode);
+    const isSnippet = isSnippetType(typeNode, snippetLocals);
+    const allowedValues = collectStringLiteralUnion(typeNode);
+    const leading = member['leadingComments'] ?? [];
+    const description = extractJsdocText(leading);
+    return {
+        name,
+        optional,
+        typeText,
+        isSnippet,
+        allowedValues,
+        description,
+        line: member.loc?.start?.line,
+        endLine: member.loc?.end?.line,
+    };
+}
+export function readMembersFromTypeLiteral(literal, snippetLocals) {
+    const members = literal['members'];
+    if (!members)
+        return [];
+    return members.map((m) => readPropertySignature(m, snippetLocals)).filter((m) => !!m);
+}
+export function readMembersFromInterfaceOrAlias(decl, snippetLocals) {
+    if (decl.type === 'TSInterfaceDeclaration') {
+        const body = decl['body']?.['body'];
+        if (!body)
+            return [];
+        return body.map((m) => readPropertySignature(m, snippetLocals)).filter((m) => !!m);
+    }
+    if (decl.type === 'TSTypeAliasDeclaration') {
+        const ann = decl['typeAnnotation'];
+        if (ann?.type === 'TSTypeLiteral')
+            return readMembersFromTypeLiteral(ann, snippetLocals);
+    }
+    return [];
+}

package/dist/src/extract/framework-adapters/svelte/helpers/extract-svelte-declaration-data.d.ts

@@ -0,0 +1,7 @@
+import type { AstNode } from '../types/svelte-ast-node.js';
+export declare function getSourceText(source: string, node: AstNode): string | null;
+export declare function getScriptText(source: string, script: AstNode | undefined): string | null;
+export declare function extractAllowedValuesFromType(type: import('ts-morph').Type): string[] | undefined;
+export declare function readJsDocFromDeclaration(decl: import('ts-morph').Node): string | undefined;
+export declare function readDeclaredTypeNodeText(decl: import('ts-morph').Node): string | null;
+export declare function typeRefersToSnippet(propType: import('ts-morph').Type): boolean;

package/dist/src/extract/framework-adapters/svelte/helpers/extract-svelte-declaration-data.js

@@ -0,0 +1,64 @@
+import { Node } from 'ts-morph';
+export function getSourceText(source, node) {
+    const start = node['start'] ?? null;
+    const end = node['end'] ?? null;
+    if (start == null || end == null)
+        return null;
+    return source.slice(start, end);
+}
+export function getScriptText(source, script) {
+    if (!script)
+        return null;
+    const content = script['content'];
+    if (!content)
+        return null;
+    return getSourceText(source, content);
+}
+export function extractAllowedValuesFromType(type) {
+    if (!type.isUnion())
+        return undefined;
+    const out = [];
+    for (const t of type.getUnionTypes()) {
+        if (!t.isStringLiteral())
+            return undefined;
+        out.push(t.getLiteralValueOrThrow());
+    }
+    return out.length > 0 ? out : undefined;
+}
+export function readJsDocFromDeclaration(decl) {
+    if (Node.isPropertySignature(decl) || Node.isInterfaceDeclaration(decl) || Node.isTypeAliasDeclaration(decl)) {
+        const jsdocs = decl.getJsDocs();
+        if (jsdocs.length > 0)
+            return jsdocs[0].getDescription().trim() || undefined;
+    }
+    return undefined;
+}
+export function readDeclaredTypeNodeText(decl) {
+    if (Node.isPropertySignature(decl))
+        return decl.getTypeNode()?.getText() ?? null;
+    return null;
+}
+export function typeRefersToSnippet(propType) {
+    const seen = new Set();
+    let cursor = propType;
+    while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        const aliasName = cursor.getAliasSymbol()?.getName();
+        const symName = cursor.getSymbol()?.getName();
+        if (aliasName === 'Snippet' || symName === 'Snippet') {
+            const decl = cursor.getAliasSymbol()?.getDeclarations()[0] ?? cursor.getSymbol()?.getDeclarations()[0];
+            const file = decl?.getSourceFile().getFilePath() ?? '';
+            if (file.includes('/svelte/') || file.includes('\\svelte\\') || file === '')
+                return true;
+        }
+        if (cursor.isUnion()) {
+            const nonUndef = cursor.getUnionTypes().filter((t) => !t.isUndefined() && !t.isNull());
+            if (nonUndef.length === 1) {
+                cursor = nonUndef[0];
+                continue;
+            }
+        }
+        break;
+    }
+    return false;
+}

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

@@ -0,0 +1,4 @@
+import type { ResolvedTypeMember } from './extract-svelte-ast-type-members.js';
+export declare function collectSnippetLocalsFromSourceFile(sf: import('ts-morph').SourceFile): Set<string>;
+export declare function readInterfaceMembers(iface: import('ts-morph').InterfaceDeclaration, snippetLocals: Set<string>): ResolvedTypeMember[];
+export declare function readTypeLiteralMembers(typeNode: import('ts-morph').TypeLiteralNode, snippetLocals: Set<string>): ResolvedTypeMember[];

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

@@ -0,0 +1,58 @@
+import { Node } from 'ts-morph';
+import { isSnippetTypeText, extractAllowedValuesFromText } from './render-svelte-type.js';
+export function collectSnippetLocalsFromSourceFile(sf) {
+    const locals = new Set();
+    for (const importDecl of sf.getImportDeclarations()) {
+        if (importDecl.getModuleSpecifierValue() !== 'svelte')
+            continue;
+        for (const named of importDecl.getNamedImports()) {
+            if (named.getName() === 'Snippet') {
+                const aliasNode = named.getAliasNode();
+                locals.add(aliasNode ? aliasNode.getText() : named.getName());
+            }
+        }
+    }
+    return locals;
+}
+export function readInterfaceMembers(iface, snippetLocals) {
+    return iface.getProperties().map((prop) => {
+        const typeNode = prop.getTypeNode();
+        const typeText = typeNode ? typeNode.getText() : prop.getType().getText(prop);
+        const allowed = extractAllowedValuesFromText(typeText);
+        const jsdocs = prop.getJsDocs();
+        const description = jsdocs.length > 0 ? jsdocs[0].getDescription().trim() : undefined;
+        return {
+            name: prop.getName(),
+            optional: prop.hasQuestionToken(),
+            typeText,
+            isSnippet: isSnippetTypeText(typeText, snippetLocals),
+            ...(allowed ? { allowedValues: allowed } : {}),
+            ...(description ? { description } : {}),
+            line: prop.getStartLineNumber(),
+            endLine: prop.getEndLineNumber(),
+        };
+    });
+}
+export function readTypeLiteralMembers(typeNode, snippetLocals) {
+    return typeNode.getMembers().flatMap((m) => {
+        if (!Node.isPropertySignature(m))
+            return [];
+        const tn = m.getTypeNode();
+        const typeText = tn ? tn.getText() : 'unknown';
+        const allowed = extractAllowedValuesFromText(typeText);
+        const jsdocs = m.getJsDocs();
+        const description = jsdocs.length > 0 ? jsdocs[0].getDescription().trim() : undefined;
+        return [
+            {
+                name: m.getName(),
+                optional: m.hasQuestionToken(),
+                typeText,
+                isSnippet: isSnippetTypeText(typeText, snippetLocals),
+                ...(allowed ? { allowedValues: allowed } : {}),
+                ...(description ? { description } : {}),
+                line: m.getStartLineNumber(),
+                endLine: m.getEndLineNumber(),
+            },
+        ];
+    });
+}

package/dist/src/extract/framework-adapters/svelte/helpers/extract-svelte-from-destructure.d.ts

@@ -0,0 +1,4 @@
+import type { AstNode } from '../types/svelte-ast-node.js';
+import type { ResolvedTypeMember } from './resolve-svelte-type-members.js';
+import type { PropsExtractionResult } from './extract-svelte-props.js';
+export declare function extractFromDestructure(propsCall: AstNode, typeMembers: ResolvedTypeMember[] | null, warnings: string[], additionalReasons?: string[]): PropsExtractionResult;

package/dist/src/extract/framework-adapters/svelte/helpers/extract-svelte-from-destructure.js

@@ -0,0 +1,85 @@
+import { renderLiteral } from './render-svelte-type.js';
+function propertyOrder(properties) {
+    const m = new Map();
+    let i = 0;
+    for (const p of properties) {
+        if (p.type !== 'Property')
+            continue;
+        const name = p['key']?.['name'] ?? null;
+        if (name)
+            m.set(name, i++);
+    }
+    return m;
+}
+function sortStable(a, b, order) {
+    const ai = order.get(a) ?? Infinity;
+    const bi = order.get(b) ?? Infinity;
+    if (ai !== bi)
+        return ai - bi;
+    return a.localeCompare(b);
+}
+export function extractFromDestructure(propsCall, typeMembers, warnings, additionalReasons) {
+    const id = propsCall['id'];
+    const properties = id['properties'] ?? [];
+    const typeByName = new Map();
+    if (typeMembers)
+        for (const m of typeMembers)
+            typeByName.set(m.name, m);
+    const props = [];
+    const snippetNames = new Set();
+    const snippetSlots = [];
+    const seenInDestructure = new Set();
+    let dropsRest = false;
+    for (const p of properties) {
+        if (p.type === 'RestElement') {
+            dropsRest = true;
+            continue;
+        }
+        if (p.type !== 'Property')
+            continue;
+        const key = p['key'];
+        const name = key?.['name'] ?? null;
+        if (!name)
+            continue;
+        seenInDestructure.add(name);
+        const value = p['value'];
+        const hasDefault = value?.type === 'AssignmentPattern';
+        const defaultValueRaw = hasDefault ? renderLiteral(value['right']) : undefined;
+        const typeMember = typeByName.get(name);
+        if (typeMember?.isSnippet) {
+            snippetNames.add(name);
+            const slot = {
+                name,
+                isDefault: name === 'children',
+                ...(typeMember.description ? { description: typeMember.description } : {}),
+            };
+            const authorText = typeMember.declaredTypeText ?? typeMember.typeText;
+            if (authorText)
+                slot._rawTypeText = authorText;
+            snippetSlots.push(slot);
+            continue;
+        }
+        const required = typeMember ? !typeMember.optional && !hasDefault : !hasDefault;
+        const propDef = {
+            name,
+            type: typeMember?.typeText ?? 'unknown',
+            required,
+        };
+        if (defaultValueRaw !== undefined)
+            propDef.defaultValue = defaultValueRaw;
+        if (typeMember?.allowedValues)
+            propDef.allowedValues = typeMember.allowedValues;
+        if (typeMember?.description)
+            propDef.description = typeMember.description;
+        props.push(propDef);
+    }
+    void dropsRest;
+    void seenInDestructure;
+    return {
+        props: props.sort((a, b) => sortStable(a.name, b.name, propertyOrder(properties))),
+        snippetNames,
+        snippetSlots,
+        warnings,
+        ...(additionalReasons && additionalReasons.length > 0 ? { additionalReasons } : {}),
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { RawSlotDefinition } from '../../../types/component.js';
+import type { AstNode } from '../types/svelte-ast-node.js';
+import { extractFromTypeMembersOnly } from './extract-svelte-type-member-props.js';
+export { extractFromTypeMembersOnly };
+export { getPropsTypeName, getRetryAnnotation } from './classify-svelte-props-annotation.js';
+export interface PropsCallContext {
+    propsCall: AstNode;
+    instance: AstNode;
+    moduleScript?: AstNode;
+    filePath: string;
+    componentName: string;
+    source: string;
+    snippetLocals: Set<string>;
+}
+export interface PropsExtractionResult {
+    props: import('../../../types/component.js').RawPropDefinition[];
+    snippetNames: Set<string>;
+    snippetSlots: RawSlotDefinition[];
+    warnings: string[];
+    additionalReasons?: string[];
+}
+export declare function extractPropsFromCall(ctx: PropsCallContext): Promise<PropsExtractionResult>;