@contentful/experience-design-system-cli 2.11.4-dev-build-0373000.0 → 2.11.4-dev-build-8f1adf3.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.11.4-dev-build-0373000.0",
+  "version": "2.11.4-dev-build-8f1adf3.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -44,6 +44,7 @@
     "react": "^18.3.1",
     "react-devtools-core": "^4.19.1",
     "react-dom": "^18.3.1",
+    "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3"
   },

package/dist/src/analyze/command.js

@@ -13,7 +13,7 @@ import { computeExtractionScore, deriveNeedsReview } from './extract/scoring.js'
 import { describeReviewReasons, inspectComponentSource } from './extract/source-inspection.js';
 import { validateExtractedComponents } from './extract/validate.js';
 import { buildAnalyzeViewRows } from './build-analyze-view-rows.js';
-const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.ts', '.tsx', '.vue']);
+const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.svelte', '.ts', '.tsx', '.vue']);
 const IGNORED_DIRECTORY_NAMES = new Set([
     '.git',
     '.next',

package/dist/src/analyze/extract/pipeline.js

@@ -4,6 +4,7 @@ import { extractVueTsxComponents } from './vue-tsx.js';
 import { extractVueComponents } from './vue.js';
 import { extractAstroComponents } from './astro.js';
 import { extractWebComponentDefinitions } from './web-components.js';
+import { extractSvelteComponents } from './svelte.js';
 const extractors = [
     {
         name: 'stencil',
@@ -35,6 +36,21 @@ const extractors = [
         fileFilter: (f) => /\.[jt]s$/.test(f) && !/\.[jt]sx$/.test(f) && !f.endsWith('.d.ts'),
         extract: extractWebComponentDefinitions,
     },
+    {
+        name: 'svelte',
+        fileFilter: (f) => {
+            if (!f.endsWith('.svelte'))
+                return false;
+            // SvelteKit route conventions: +page.svelte, +layout.svelte, +error.svelte
+            // are framework-managed entrypoints, not authorable design-system components.
+            // Mirrors how Next.js page.tsx / layout.tsx are filtered in pre-classify.
+            const filename = f.replace(/\\/g, '/').split('/').pop() ?? '';
+            if (/^\+(page|layout|error)\.svelte$/.test(filename))
+                return false;
+            return true;
+        },
+        extract: extractSvelteComponents,
+    },
 ];
 function getPathPreferenceScore(filePath) {
     const normalized = filePath.replace(/\\/g, '/');

package/dist/src/analyze/extract/svelte.d.ts

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

package/dist/src/analyze/extract/svelte.js

@@ -0,0 +1,913 @@
+import { basename, dirname, resolve, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { existsSync, statSync } from 'node:fs';
+import os from 'node:os';
+import { parse as parseSvelte } from 'svelte/compiler';
+import { Project, Node } from 'ts-morph';
+import { computeExtractionScore, deriveNeedsReview } from './scoring.js';
+const SVELTE_EXTRACT_CONCURRENCY = Number(process.env['EDS_EXTRACT_CONCURRENCY'] ?? 0) || os.cpus().length;
+export async function extractSvelteComponents(filePaths, onProgress) {
+    const svelteFiles = filePaths.filter((f) => f.endsWith('.svelte'));
+    if (svelteFiles.length === 0)
+        return { components: [], warnings: [] };
+    const warnings = [];
+    const components = [];
+    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 } = await extractFromSvelteFile(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(SVELTE_EXTRACT_CONCURRENCY, svelteFiles.length) }, worker));
+    return {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings,
+    };
+}
+async function extractFromSvelteFile(filePath, source) {
+    const warnings = [];
+    let ast;
+    try {
+        ast = parseSvelte(source, { modern: true });
+    }
+    catch (e) {
+        return {
+            component: null,
+            warnings: [`Parse error in ${filePath}: ${e instanceof Error ? e.message : String(e)}`],
+        };
+    }
+    const name = getSvelteComponentName(filePath);
+    const instance = ast['instance'];
+    const moduleScript = ast['module'];
+    const fragment = ast['fragment'];
+    // Detect Svelte 4 export-let syntax — currently unsupported.
+    if (instance && hasV4ExportLetProps(instance)) {
+        warnings.push(`Svelte 4 export let syntax not yet supported (file: ${filePath}); see INTEG-4267 for v5-only scope and follow-up`);
+        return { component: null, warnings };
+    }
+    // Find the $props() call (Svelte 5 runes).
+    const propsCall = instance ? findPropsCall(instance) : null;
+    // Snippet import map: localName -> true if it refers to `Snippet` from 'svelte'.
+    const snippetLocals = instance ? collectSnippetImportLocals(instance) : new Set();
+    // --- Props extraction ---
+    let props = [];
+    let propNamesTreatedAsSnippet = new Set();
+    let snippetSlotsFromProps = [];
+    if (propsCall) {
+        const result = await extractPropsFromCall({
+            propsCall,
+            instance: instance,
+            moduleScript,
+            filePath,
+            source,
+            snippetLocals,
+        });
+        props = result.props;
+        propNamesTreatedAsSnippet = result.snippetNames;
+        snippetSlotsFromProps = result.snippetSlots;
+        warnings.push(...result.warnings);
+    }
+    else if (instance) {
+        // No $props() call. We've already ruled out v4 above; this means $props was used
+        // but couldn't be located, or the script has no rune-style props at all.
+        // Component still extracted (slots from template may exist).
+    }
+    else {
+        // No script block at all — nothing to extract on the props side.
+        warnings.push(`${filePath} has no instance script block; no props extracted`);
+    }
+    // --- Slot extraction ---
+    const templateSlots = fragment ? extractTemplateSlots(fragment) : [];
+    const { slots, mixedWarning } = mergeSlots(snippetSlotsFromProps, templateSlots);
+    if (mixedWarning) {
+        warnings.push(`${filePath}: mixed Snippet and <slot> usage detected; preferring Snippet entries`);
+    }
+    const component = {
+        name,
+        source: filePath,
+        framework: 'svelte',
+        props,
+        slots,
+    };
+    // Score & flag review.
+    const score = computeExtractionScore(component);
+    component.extractionConfidence = score.confidence;
+    component.reviewReasons = score.reasons;
+    component.needsReview = deriveNeedsReview(score.confidence);
+    // Validation issues (EMPTY_COMPONENT_NAME / EMPTY_PROP_NAME / PROP_SLOT_NAME_COLLISION /
+    // DUPLICATE_COMPONENT_NAME / EMPTY_COMPONENT / EMPTY_SLOT_NAME) are populated
+    // centrally by validateExtractedComponents() in analyze/command.ts after all
+    // extractors return — same convention as React, Vue, Astro, Stencil, and
+    // web-components. No per-extractor work needed here.
+    void propNamesTreatedAsSnippet; // currently informational; reserved for future validation
+    return { component, warnings };
+}
+// ---------------------------------------------------------------------------
+// Component name
+// ---------------------------------------------------------------------------
+function getSvelteComponentName(filePath) {
+    const file = basename(filePath, '.svelte');
+    // index.svelte → use parent directory name (mirrors index.vue behavior).
+    if (file === 'index') {
+        const parent = basename(dirname(filePath));
+        return toPascalCase(parent);
+    }
+    return toPascalCase(file);
+}
+function toPascalCase(s) {
+    if (!s)
+        return s;
+    // Already PascalCase? leave it.
+    if (/^[A-Z]/.test(s) && !s.includes('-') && !s.includes('_'))
+        return s;
+    return s
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}
+// ---------------------------------------------------------------------------
+// Detection helpers
+// ---------------------------------------------------------------------------
+function hasV4ExportLetProps(instance) {
+    const body = instance['content']?.['body'];
+    if (!body)
+        return false;
+    return body.some((stmt) => {
+        if (stmt.type !== 'ExportNamedDeclaration')
+            return false;
+        const decl = stmt['declaration'];
+        return decl?.type === 'VariableDeclaration' && decl['kind'] === 'let';
+    });
+}
+function findPropsCall(instance) {
+    const body = instance['content']?.['body'];
+    if (!body)
+        return null;
+    let found = null;
+    for (const stmt of body) {
+        if (stmt.type !== 'VariableDeclaration')
+            continue;
+        const decls = stmt['declarations'];
+        if (!decls)
+            continue;
+        for (const d of decls) {
+            const init = d['init'];
+            if (!init || init.type !== 'CallExpression')
+                continue;
+            const callee = init['callee'];
+            if (callee?.type === 'Identifier' && callee['name'] === '$props') {
+                if (found === null)
+                    found = d;
+                // Multiple $props() calls — first wins; we'll warn from the caller.
+            }
+        }
+    }
+    return found;
+}
+function collectSnippetImportLocals(instance) {
+    const locals = new Set();
+    const body = instance['content']?.['body'];
+    if (!body)
+        return locals;
+    for (const stmt of body) {
+        if (stmt.type !== 'ImportDeclaration')
+            continue;
+        const sourceNode = stmt['source'];
+        if (sourceNode?.['value'] !== 'svelte')
+            continue;
+        const specs = stmt['specifiers'];
+        if (!specs)
+            continue;
+        for (const spec of specs) {
+            if (spec.type !== 'ImportSpecifier')
+                continue;
+            const imported = spec['imported'];
+            const local = spec['local'];
+            if (imported?.['name'] === 'Snippet' && typeof local?.['name'] === 'string') {
+                locals.add(local['name']);
+            }
+        }
+    }
+    return locals;
+}
+async function extractPropsFromCall(ctx) {
+    const warnings = [];
+    const propsCall = ctx.propsCall;
+    const id = propsCall['id'];
+    const idType = id?.type;
+    // Decode the type annotation (the right side of `: Props` / `: { ... }`).
+    const annotation = id?.['typeAnnotation']?.['typeAnnotation'];
+    // Resolve the type members once (works for both ObjectPattern and Identifier id forms).
+    const typeMembers = annotation
+        ? await resolveTypeMembers(annotation, ctx.instance, ctx.moduleScript, ctx.filePath, ctx.source)
+        : null;
+    if (idType === 'ObjectPattern') {
+        return extractFromDestructure(ctx.propsCall, ctx, typeMembers, warnings);
+    }
+    if (idType === 'Identifier') {
+        // const props: Props = $props(); — no destructure, no defaults, no per-name binding.
+        if (typeMembers) {
+            return extractFromTypeMembersOnly(typeMembers, ctx.snippetLocals, warnings);
+        }
+        warnings.push(`${ctx.filePath}: $props() called without destructuring; cannot extract individual props`);
+        return { props: [], snippetNames: new Set(), snippetSlots: [], warnings };
+    }
+    warnings.push(`${ctx.filePath}: unrecognized $props() binding pattern (${idType})`);
+    return { props: [], snippetNames: new Set(), snippetSlots: [], warnings };
+}
+async function resolveTypeMembers(annotation, instance, moduleScript, filePath, source) {
+    // Snippet imports may live in either script block; collect from both.
+    const snippetLocals = mergeSets(collectSnippetImportLocals(instance), moduleScript ? collectSnippetImportLocals(moduleScript) : new Set());
+    // Fast path 1: inline type literal with no extends/intersection. The AST already
+    // gives us member-level optional/type/JSDoc; no ts-morph needed.
+    if (annotation.type === 'TSTypeLiteral') {
+        return readMembersFromTypeLiteral(annotation, snippetLocals);
+    }
+    // For named refs: try the AST fast path first (inline interface or type literal alias
+    // with no heritage clauses). If that returns >0 members AND the source declaration has
+    // no extends, we trust it. Otherwise fall back to ts-morph type-checker resolution to
+    // pick up extends / Omit / intersection / Partial / generics.
+    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;
+                }
+                // Heritage or empty body — fall through to ts-morph resolution.
+            }
+            else {
+                // No local declaration — try import resolution via ts-morph.
+                const imported = (await resolveImportedTypeMembers(refName, instance, filePath)) ??
+                    (moduleScript ? await resolveImportedTypeMembers(refName, moduleScript, filePath) : null);
+                if (imported)
+                    return imported;
+            }
+        }
+    }
+    // Slow path: ts-morph type-checker resolution. Materializes the annotation text as
+    // `type __SveltePropsT__ = <annotation>;` inside an in-memory file containing the
+    // combined script bodies, then reads .getType().getProperties(). The TS checker
+    // resolves extends, &, Omit, Pick, Partial, generics — anything TS itself resolves.
+    return resolveViaTypeChecker(annotation, instance, moduleScript, filePath, source, snippetLocals);
+}
+function declarationHasHeritage(decl) {
+    if (decl.type === 'TSInterfaceDeclaration') {
+        const ext = decl['extends'];
+        return Array.isArray(ext) && ext.length > 0;
+    }
+    return false;
+}
+async function resolveViaTypeChecker(annotation, instance, moduleScript, filePath, source, snippetLocals) {
+    const annotationText = sliceSource(source, annotation);
+    if (!annotationText)
+        return null;
+    // Reconstruct the combined script content: module-script first, then instance.
+    // Both bodies share scope in the synthetic file, which is enough for TS to resolve
+    // local interfaces, type aliases, imports, and heritage clauses across them.
+    const moduleText = sliceScriptContent(source, moduleScript);
+    const instanceText = sliceScriptContent(source, instance);
+    const synthetic = [moduleText, instanceText, `type __SveltePropsT__ = ${annotationText};`].filter(Boolean).join('\n');
+    const project = new Project({
+        compilerOptions: { strict: false, target: 99, module: 99, allowJs: true, jsx: 1 },
+        useInMemoryFileSystem: false,
+        skipAddingFilesFromTsConfig: true,
+    });
+    // Place the synthetic file alongside the .svelte so relative imports resolve.
+    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 type = alias.getType();
+    const apparent = type.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);
+        // Strip ` | undefined` for clean output on optional props.
+        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 isSnippet = isSnippetTypeText(typeText, snippetLocals);
+        members.push({
+            name,
+            optional,
+            typeText,
+            isSnippet,
+            ...(allowed ? { allowedValues: allowed } : {}),
+            ...(description ? { description } : {}),
+            // line/endLine: prefer AST-derived location when the source declaration is in our
+            // svelte file. ts-morph's synthetic location refers to the synthetic file and
+            // isn't useful for the user.
+        });
+    }
+    return members;
+}
+function sliceSource(source, node) {
+    const start = node['start'] ?? null;
+    const end = node['end'] ?? null;
+    if (start == null || end == null)
+        return null;
+    return source.slice(start, end);
+}
+function sliceScriptContent(source, script) {
+    if (!script)
+        return null;
+    const content = script['content'];
+    if (!content)
+        return null;
+    return sliceSource(source, content);
+}
+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;
+}
+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;
+}
+function isSnippetTypeText(typeText, snippetLocals) {
+    // Direct match against the local Snippet name (handles aliasing).
+    for (const local of snippetLocals) {
+        if (typeText === local || typeText.startsWith(`${local}<`))
+            return true;
+    }
+    // Defensive fallback: TS may surface the canonical `Snippet` from the import.
+    return typeText === 'Snippet' || typeText.startsWith('Snippet<');
+}
+function mergeSets(a, b) {
+    const out = new Set(a);
+    for (const v of b)
+        out.add(v);
+    return out;
+}
+function findLocalTypeDeclaration(instance, name, module) {
+    // Skeleton-svelte and similar libraries declare the Props interface in
+    // <script lang="ts" module> and consume it in the regular <script>. Look
+    // in both bodies. Type declarations may also be wrapped in
+    // `export { ... }` statements (ExportNamedDeclaration with .declaration).
+    for (const script of [instance, module]) {
+        const body = script?.['content']?.['body'];
+        if (!body)
+            continue;
+        for (const stmt of body) {
+            const decl = stmt.type === 'ExportNamedDeclaration' ? (stmt['declaration'] ?? stmt) : stmt;
+            if (decl.type === 'TSInterfaceDeclaration' || decl.type === 'TSTypeAliasDeclaration') {
+                const id = decl['id'];
+                if (id?.['name'] === name)
+                    return decl;
+            }
+        }
+    }
+    return null;
+}
+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 [];
+}
+function readMembersFromTypeLiteral(literal, snippetLocals) {
+    const members = literal['members'];
+    if (!members)
+        return [];
+    return members.map((m) => readPropertySignature(m, snippetLocals)).filter((m) => !!m);
+}
+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);
+    // JSDoc / comments — `leadingComments` may be on the member or on the parent.
+    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,
+    };
+}
+function isSnippetType(typeNode, snippetLocals) {
+    if (!typeNode)
+        return false;
+    if (typeNode.type !== 'TSTypeReference')
+        return false;
+    const tn = typeNode['typeName']?.['name'];
+    if (!tn)
+        return false;
+    return snippetLocals.has(tn);
+}
+function collectStringLiteralUnion(typeNode) {
+    if (!typeNode)
+        return undefined;
+    if (typeNode.type !== 'TSUnionType')
+        return undefined;
+    const members = typeNode['types'];
+    if (!members)
+        return undefined;
+    const out = [];
+    for (const m of members) {
+        if (m.type !== 'TSLiteralType')
+            return undefined; // not a pure literal union
+        const lit = m['literal'];
+        const v = lit?.['value'];
+        if (typeof v !== 'string')
+            return undefined;
+        out.push(v);
+    }
+    return out.length > 0 ? out : undefined;
+}
+function renderType(typeNode) {
+    if (!typeNode)
+        return 'unknown';
+    switch (typeNode.type) {
+        case 'TSStringKeyword':
+            return 'string';
+        case 'TSNumberKeyword':
+            return 'number';
+        case 'TSBooleanKeyword':
+            return 'boolean';
+        case 'TSAnyKeyword':
+            return 'any';
+        case 'TSUnknownKeyword':
+            return 'unknown';
+        case 'TSNullKeyword':
+            return 'null';
+        case 'TSUndefinedKeyword':
+            return 'undefined';
+        case 'TSVoidKeyword':
+            return 'void';
+        case 'TSArrayType': {
+            return `${renderType(typeNode['elementType'])}[]`;
+        }
+        case 'TSUnionType': {
+            const members = typeNode['types'] ?? [];
+            return members.map(renderType).join(' | ');
+        }
+        case 'TSLiteralType': {
+            const lit = typeNode['literal'];
+            const v = lit?.['value'];
+            if (typeof v === 'string')
+                return `'${v}'`;
+            if (typeof v === 'number' || typeof v === 'boolean')
+                return String(v);
+            return 'unknown';
+        }
+        case 'TSTypeReference': {
+            const tn = typeNode['typeName']?.['name'];
+            const args = typeNode['typeArguments'];
+            const base = tn ?? 'unknown';
+            const params = args?.['params'] ?? null;
+            if (params && params.length > 0) {
+                return `${base}<${params.map(renderType).join(', ')}>`;
+            }
+            return base;
+        }
+        case 'TSFunctionType': {
+            const params = (typeNode['params'] ?? []).map((p) => {
+                const ann = p['typeAnnotation']?.['typeAnnotation'];
+                const pname = p['name'] ?? 'arg';
+                return `${pname}: ${renderType(ann)}`;
+            });
+            const ret = typeNode['returnType']?.['typeAnnotation'];
+            return `(${params.join(', ')}) => ${renderType(ret)}`;
+        }
+        default:
+            return 'unknown';
+    }
+}
+function extractJsdocText(comments) {
+    if (!comments.length)
+        return undefined;
+    const last = comments[comments.length - 1];
+    if (last.type !== 'Block')
+        return undefined;
+    // Strip leading * on each line, trim, join.
+    const text = last.value
+        .split('\n')
+        .map((l) => l.replace(/^\s*\*\s?/, '').trim())
+        .filter(Boolean)
+        .join(' ')
+        .trim();
+    return text || undefined;
+}
+// ---------------------------------------------------------------------------
+// Extraction: ObjectPattern destructure + type-members
+// ---------------------------------------------------------------------------
+function extractFromDestructure(propsCall, ctx, typeMembers, warnings) {
+    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);
+            snippetSlots.push({
+                name,
+                isDefault: name === 'children',
+                ...(typeMember.description ? { description: typeMember.description } : {}),
+            });
+            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);
+    }
+    // Note: members declared in the type but not destructured are intentionally NOT surfaced
+    // here. With `let { foo, ...rest } = $props()`, only `foo` is bound by name; the rest
+    // are collected into the rest binding and are not individually addressable. Authoring
+    // contract = the destructure list. (Type-members-only path runs separately for the
+    // `const props: Props = $props()` no-destructure case.)
+    if (dropsRest) {
+        warnings.push(`${ctx.filePath}: rest element in $props() destructure dropped (cannot enumerate)`);
+    }
+    return {
+        props: props.sort((a, b) => sortStable(a.name, b.name, propertyOrder(properties))),
+        snippetNames,
+        snippetSlots,
+        warnings,
+    };
+}
+function extractFromTypeMembersOnly(typeMembers, _snippetLocals, _warnings) {
+    const props = [];
+    const snippetNames = new Set();
+    const snippetSlots = [];
+    for (const m of typeMembers) {
+        if (m.isSnippet) {
+            snippetNames.add(m.name);
+            snippetSlots.push({
+                name: m.name,
+                isDefault: m.name === 'children',
+                ...(m.description ? { description: m.description } : {}),
+            });
+            continue;
+        }
+        const propDef = {
+            name: m.name,
+            type: m.typeText,
+            required: !m.optional,
+        };
+        if (m.allowedValues)
+            propDef.allowedValues = m.allowedValues;
+        if (m.description)
+            propDef.description = m.description;
+        props.push(propDef);
+    }
+    return { props, snippetNames, snippetSlots, warnings: [] };
+}
+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);
+}
+function renderLiteral(node) {
+    if (!node)
+        return undefined;
+    if (node.type === 'Literal') {
+        const v = node['value'];
+        const raw = node['raw'];
+        if (typeof v === 'string')
+            return `'${v}'`;
+        if (typeof raw === 'string')
+            return raw;
+        if (v === null)
+            return 'null';
+        return String(v);
+    }
+    if (node.type === 'Identifier')
+        return node['name'] ?? undefined;
+    if (node.type === 'ArrayExpression') {
+        const els = node['elements'] ?? [];
+        return `[${els.map((e) => renderLiteral(e) ?? '').join(', ')}]`;
+    }
+    if (node.type === 'ObjectExpression')
+        return '{}';
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Imported Props resolution via ts-morph (cross-file)
+// ---------------------------------------------------------------------------
+async function resolveImportedTypeMembers(typeName, instance, filePath) {
+    const body = instance['content']?.['body'];
+    if (!body)
+        return null;
+    for (const stmt of body) {
+        if (stmt.type !== 'ImportDeclaration')
+            continue;
+        const specifierValue = stmt['source']?.['value'];
+        if (!specifierValue || !specifierValue.startsWith('.'))
+            continue;
+        const specifiers = stmt['specifiers'] ?? [];
+        let importedExport = null;
+        for (const spec of specifiers) {
+            if (spec.type !== 'ImportSpecifier')
+                continue;
+            const localName = spec['local']?.['name'];
+            if (localName === typeName) {
+                importedExport = spec['imported']?.['name'] ?? null;
+                break;
+            }
+        }
+        if (!importedExport)
+            continue;
+        const resolvedFile = resolveLocalScriptModule(filePath, specifierValue);
+        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;
+    }
+    // Fallback: handle `.js` import that maps to a `.ts` source on disk (NodeNext convention)
+    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: { strict: false, target: 99, module: 99, allowJs: true },
+        useInMemoryFileSystem: false,
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sf = project.addSourceFileAtPathIfExists(filePath);
+    if (!sf)
+        return null;
+    // Use getExportedDeclarations() so re-export chains (`export { ... } from './x'`,
+    // `export * from './x'`, named or namespace) resolve transparently. ts-morph
+    // follows them recursively and returns the underlying declaration.
+    const exportedDeclarations = sf.getExportedDeclarations();
+    const decls = exportedDeclarations.get(exportName);
+    if (!decls || decls.length === 0)
+        return null;
+    for (const decl of decls) {
+        if (Node.isInterfaceDeclaration(decl)) {
+            return readInterfaceMembers(decl);
+        }
+        if (Node.isTypeAliasDeclaration(decl)) {
+            const typeNode = decl.getTypeNode();
+            if (typeNode && Node.isTypeLiteral(typeNode)) {
+                return readTypeLiteralMembers(typeNode);
+            }
+        }
+    }
+    return null;
+}
+function readInterfaceMembers(iface) {
+    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: typeText === 'Snippet' || /^Snippet</.test(typeText),
+            ...(allowed ? { allowedValues: allowed } : {}),
+            ...(description ? { description } : {}),
+            line: prop.getStartLineNumber(),
+            endLine: prop.getEndLineNumber(),
+        };
+    });
+}
+function readTypeLiteralMembers(typeNode) {
+    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: typeText === 'Snippet' || /^Snippet</.test(typeText),
+                ...(allowed ? { allowedValues: allowed } : {}),
+                ...(description ? { description } : {}),
+                line: m.getStartLineNumber(),
+                endLine: m.getEndLineNumber(),
+            },
+        ];
+    });
+}
+function extractAllowedValuesFromText(typeText) {
+    // Quick parse of `'a' | 'b' | 'c'`.
+    const parts = typeText
+        .split('|')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (parts.length < 2)
+        return undefined;
+    const out = [];
+    for (const p of parts) {
+        const m = p.match(/^'([^']*)'$/) ?? p.match(/^"([^"]*)"$/);
+        if (!m)
+            return undefined;
+        out.push(m[1]);
+    }
+    return out.length > 0 ? out : undefined;
+}
+// ---------------------------------------------------------------------------
+// Slot extraction (template <slot> + Snippet props merge)
+// ---------------------------------------------------------------------------
+function extractTemplateSlots(fragment) {
+    const slots = [];
+    const seen = new Set();
+    walk(fragment);
+    return slots;
+    function walk(node) {
+        if (!node)
+            return;
+        if (node.type === 'SlotElement') {
+            const name = readSlotName(node);
+            if (!seen.has(name)) {
+                seen.add(name);
+                slots.push({ name, isDefault: name === 'default' });
+            }
+        }
+        const children = node['nodes'] ?? node['children'] ?? [];
+        for (const c of children)
+            walk(c);
+        const fragChild = node['fragment'];
+        if (fragChild)
+            walk(fragChild);
+    }
+}
+function readSlotName(slotEl) {
+    const attrs = slotEl['attributes'] ?? [];
+    for (const attr of attrs) {
+        if (attr['name'] !== 'name')
+            continue;
+        const value = attr['value'];
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                if (v.type === 'Text' && typeof v['data'] === 'string')
+                    return v['data'];
+            }
+        }
+    }
+    return 'default';
+}
+function mergeSlots(fromSnippetProps, fromTemplate) {
+    if (fromSnippetProps.length === 0)
+        return { slots: fromTemplate, mixedWarning: false };
+    if (fromTemplate.length === 0)
+        return { slots: fromSnippetProps, mixedWarning: false };
+    const byName = new Map();
+    for (const s of fromSnippetProps)
+        byName.set(s.name, s);
+    const snippetHasDefault = fromSnippetProps.some((s) => s.isDefault);
+    let mixed = false;
+    for (const s of fromTemplate) {
+        // Default <slot/> in template is the same surface as a `children: Snippet` prop.
+        // Prefer the Snippet entry when both are present.
+        if (s.isDefault && snippetHasDefault) {
+            mixed = true;
+            continue;
+        }
+        if (byName.has(s.name)) {
+            mixed = true;
+            continue;
+        }
+        byName.set(s.name, s);
+    }
+    return { slots: [...byName.values()], mixedWarning: mixed };
+}

package/dist/src/analyze/select-agent/context-builder.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.ts', '.tsx', '.vue']);
+const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.svelte', '.ts', '.tsx', '.vue']);
 const IMPORT_PATTERN = /import\s+(?:type\s+)?(.+?)\s+from\s+['"]([^'"]+)['"]/g;
 const EXPORT_NAMED_PATTERN = /export\s+(?:const|function|class|type|interface|enum)\s+([A-Za-z0-9_]+)/g;
 const EXPORT_DEFAULT_PATTERN = /export\s+default\s+([A-Za-z0-9_]+)/g;

package/dist/src/analyze/tui/AnalyzeView.d.ts

@@ -5,7 +5,7 @@ export type AnalyzeViewResult = {
     fileCount: number;
     components: Array<{
         name: string;
-        framework: 'react' | 'next' | 'vue' | 'astro' | 'web-component' | 'stencil';
+        framework: 'react' | 'next' | 'vue' | 'astro' | 'web-component' | 'stencil' | 'svelte';
         propCount: number;
         slotCount: number;
         warnings: string[];

package/dist/src/types.d.ts

@@ -32,7 +32,7 @@ export interface RawSlotDefinition {
 export interface RawComponentDefinition {
     name: string;
     source: string;
-    framework: 'react' | 'next' | 'vue' | 'astro' | 'web-component' | 'stencil';
+    framework: 'react' | 'next' | 'vue' | 'astro' | 'web-component' | 'stencil' | 'svelte';
     props: RawPropDefinition[];
     slots: RawSlotDefinition[];
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.11.4-dev-build-0373000.0",
+  "version": "2.11.4-dev-build-8f1adf3.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -34,9 +34,10 @@
     "react": "^18.3.1",
     "react-devtools-core": "^4.19.1",
     "react-dom": "^18.3.1",
+    "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.11.4-dev-build-0373000.0"
+    "@contentful/experience-design-system-types": "2.11.4-dev-build-8f1adf3.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",