@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/classify-svelte-props-annotation.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,55 +0,0 @@
-import { resolveTypeMembers } from './resolve-svelte-type-members.js';
-import { extractFromDestructure } from './extract-svelte-from-destructure.js';
-import { extractFromTypeMembersOnly } from './extract-svelte-type-member-props.js';
-import { formatAnnotation, classifyUnresolved } from './classify-svelte-props-annotation.js';
-export { extractFromTypeMembersOnly };
-export { getPropsTypeName, getRetryAnnotation } from './classify-svelte-props-annotation.js';
-export async function extractPropsFromCall(ctx) {
-    const warnings = [];
-    const propsCall = ctx.propsCall;
-    const id = propsCall['id'];
-    const idType = id?.type;
-    const annotation = id?.['typeAnnotation']?.['typeAnnotation'];
-    const typeMembers = annotation
-        ? await resolveTypeMembers(annotation, ctx.instance, ctx.moduleScript, ctx.filePath, ctx.source)
-        : null;
-    const unresolved = classifyUnresolved(annotation, typeMembers, ctx.instance, ctx.moduleScript);
-    const additionalReasons = [];
-    if (unresolved) {
-        const refLabel = formatAnnotation(annotation);
-        const heritageNote = unresolved === 'partial-heritage' ? ' (heritage clauses extending unreachable types)' : '';
-        warnings.push(`${ctx.componentName}: declared Props type ${refLabel} resolved to ${unresolved === 'empty' ? '0' : 'only Snippet-typed'} properties${heritageNote} (${ctx.filePath}) — possible cross-package extends or unreachable type. ` +
-            `See https://github.com/contentful/experience-design-system-sdk-public/pull/44 for context and partner workarounds.`);
-        additionalReasons.push('props-type-unresolved');
-    }
-    if (idType === 'ObjectPattern') {
-        return extractFromDestructure(ctx.propsCall, typeMembers, warnings, additionalReasons);
-    }
-    if (idType === 'Identifier') {
-        if (typeMembers && typeMembers.length > 0) {
-            return {
-                ...extractFromTypeMembersOnly(typeMembers),
-                warnings,
-                additionalReasons,
-            };
-        }
-        if (!unresolved) {
-            warnings.push(`${ctx.componentName}: $props() called without destructuring (${ctx.filePath}); cannot extract individual props`);
-        }
-        return {
-            props: [],
-            snippetNames: new Set(),
-            snippetSlots: [],
-            warnings,
-            additionalReasons,
-        };
-    }
-    warnings.push(`${ctx.componentName}: unrecognized $props() binding pattern '${idType}' (${ctx.filePath})`);
-    return {
-        props: [],
-        snippetNames: new Set(),
-        snippetSlots: [],
-        warnings,
-        additionalReasons,
-    };
-}

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

@@ -1,7 +0,0 @@
-import type { RawSlotDefinition } from '../../../types/component.js';
-import type { AstNode } from '../types/svelte-ast-node.js';
-export declare function extractTemplateSlots(fragment: AstNode): RawSlotDefinition[];
-export declare function mergeSlots(fromSnippetProps: RawSlotDefinition[], fromTemplate: RawSlotDefinition[]): {
-    slots: RawSlotDefinition[];
-    mixedWarning: boolean;
-};

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

@@ -1,63 +0,0 @@
-export function extractTemplateSlots(fragment) {
-    const slots = new Map();
-    const seen = new Set();
-    walk(fragment);
-    return [...slots.entries()]
-        .map(([name, isDefault]) => ({ name, isDefault }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    function walk(node) {
-        if (!node)
-            return;
-        if (node.type === 'SlotElement') {
-            const name = readSlotName(node);
-            if (!seen.has(name)) {
-                seen.add(name);
-                slots.set(name, name === 'default');
-            }
-        }
-        const children = node['nodes'] ?? node['children'] ?? [];
-        for (const child of children)
-            walk(child);
-        const fragmentChild = node['fragment'];
-        if (fragmentChild)
-            walk(fragmentChild);
-    }
-}
-function readSlotName(slotElement) {
-    const attrs = slotElement['attributes'] ?? [];
-    for (const attr of attrs) {
-        if (attr['name'] !== 'name')
-            continue;
-        const value = attr['value'];
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (item.type === 'Text' && typeof item['data'] === 'string')
-                    return item['data'];
-            }
-        }
-    }
-    return 'default';
-}
-export 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 slot of fromSnippetProps)
-        byName.set(slot.name, slot);
-    const snippetHasDefault = fromSnippetProps.some((slot) => slot.isDefault);
-    let mixed = false;
-    for (const slot of fromTemplate) {
-        if (slot.isDefault && snippetHasDefault) {
-            mixed = true;
-            continue;
-        }
-        if (byName.has(slot.name)) {
-            mixed = true;
-            continue;
-        }
-        byName.set(slot.name, slot);
-    }
-    return { slots: [...byName.values()], mixedWarning: mixed };
-}

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

@@ -1,3 +0,0 @@
-import type { ResolvedTypeMember } from './resolve-svelte-type-members.js';
-import type { PropsExtractionResult } from './extract-svelte-props.js';
-export declare function extractFromTypeMembersOnly(typeMembers: ResolvedTypeMember[]): PropsExtractionResult;