@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/extract-svelte-type-member-props.js

@@ -1,31 +0,0 @@
-export function extractFromTypeMembersOnly(typeMembers) {
-    const props = [];
-    const snippetNames = new Set();
-    const snippetSlots = [];
-    for (const m of typeMembers) {
-        if (m.isSnippet) {
-            snippetNames.add(m.name);
-            const slot = {
-                name: m.name,
-                isDefault: m.name === 'children',
-                ...(m.description ? { description: m.description } : {}),
-            };
-            const authorText = m.declaredTypeText ?? m.typeText;
-            if (authorText)
-                slot._rawTypeText = authorText;
-            snippetSlots.push(slot);
-            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: [] };
-}

package/dist/src/extract/framework-adapters/svelte/helpers/find-svelte-script-declarations.d.ts

@@ -1,8 +0,0 @@
-import type { AstNode } from '../types/svelte-ast-node.js';
-export { collectReferencedTypeNames, collectImportSpecifiersForNames } from './collect-svelte-type-references.js';
-export declare function hasV4ExportLetProps(instance: AstNode): boolean;
-export declare function findPropsCall(instance: AstNode): AstNode | null;
-export declare function collectSnippetImportLocals(instance: AstNode): Set<string>;
-export declare function findLocalTypeDeclaration(instance: AstNode, name: string, module?: AstNode): AstNode | null;
-export declare function declarationHasHeritage(decl: AstNode): boolean;
-export declare function mergeSets<T>(a: Set<T>, b: Set<T>): Set<T>;

package/dist/src/extract/framework-adapters/svelte/helpers/find-svelte-script-declarations.js

@@ -1,91 +0,0 @@
-export { collectReferencedTypeNames, collectImportSpecifiersForNames } from './collect-svelte-type-references.js';
-export 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';
-    });
-}
-export 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;
-            }
-        }
-    }
-    return found;
-}
-export 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;
-}
-export function findLocalTypeDeclaration(instance, name, module) {
-    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;
-}
-export function declarationHasHeritage(decl) {
-    if (decl.type === 'TSInterfaceDeclaration') {
-        const ext = decl['extends'];
-        return Array.isArray(ext) && ext.length > 0;
-    }
-    return false;
-}
-export function mergeSets(a, b) {
-    const out = new Set(a);
-    for (const v of b)
-        out.add(v);
-    return out;
-}

package/dist/src/extract/framework-adapters/svelte/helpers/get-svelte-component-name.d.ts

@@ -1 +0,0 @@
-export declare function getSvelteComponentName(filePath: string): string;

package/dist/src/extract/framework-adapters/svelte/helpers/get-svelte-component-name.js

@@ -1,26 +0,0 @@
-import { basename, dirname } from 'node:path';
-const ANATOMY_FOLDERS = new Set(['anatomy', 'parts']);
-export function getSvelteComponentName(filePath) {
-    const file = basename(filePath, '.svelte');
-    const parentDir = basename(dirname(filePath));
-    if (file === 'index')
-        return toPascalCase(parentDir);
-    if (ANATOMY_FOLDERS.has(parentDir)) {
-        const grandparent = basename(dirname(dirname(filePath)));
-        if (grandparent && grandparent !== '.' && grandparent !== '/') {
-            return `${toPascalCase(grandparent)}${toPascalCase(file)}`;
-        }
-    }
-    return toPascalCase(file);
-}
-function toPascalCase(s) {
-    if (!s)
-        return s;
-    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('');
-}

package/dist/src/extract/framework-adapters/svelte/helpers/render-svelte-type-strings.d.ts

@@ -1,3 +0,0 @@
-import type { AstNode } from '../types/svelte-ast-node.js';
-export declare function renderType(typeNode: AstNode | undefined): string;
-export declare function renderLiteral(node: AstNode | undefined): string | undefined;

package/dist/src/extract/framework-adapters/svelte/helpers/render-svelte-type-strings.js

@@ -1,91 +0,0 @@
-export 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 'TSTupleType': {
-            const elements = typeNode['elementTypes'] ?? [];
-            return `[${elements
-                .map((el) => {
-                if (el.type === 'TSNamedTupleMember')
-                    return renderType(el['elementType']);
-                return renderType(el);
-            })
-                .join(', ')}]`;
-        }
-        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';
-    }
-}
-export 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;
-}

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

@@ -1,11 +0,0 @@
-import type { AstNode } from '../types/svelte-ast-node.js';
-export { renderType, renderLiteral } from './render-svelte-type-strings.js';
-interface Comment {
-    type: 'Line' | 'Block';
-    value: string;
-}
-export declare function isSnippetTypeText(typeText: string, snippetLocals: Set<string>): boolean;
-export declare function isSnippetType(typeNode: AstNode | undefined, snippetLocals: Set<string>): boolean;
-export declare function collectStringLiteralUnion(typeNode: AstNode | undefined): string[] | undefined;
-export declare function extractAllowedValuesFromText(typeText: string): string[] | undefined;
-export declare function extractJsdocText(comments: Comment[]): string | undefined;

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

@@ -1,68 +0,0 @@
-export { renderType, renderLiteral } from './render-svelte-type-strings.js';
-export function isSnippetTypeText(typeText, snippetLocals) {
-    for (const local of snippetLocals) {
-        if (typeText === local || typeText.startsWith(`${local}<`))
-            return true;
-    }
-    return typeText === 'Snippet' || typeText.startsWith('Snippet<');
-}
-export 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);
-}
-export 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;
-        const lit = m['literal'];
-        const v = lit?.['value'];
-        if (typeof v !== 'string')
-            return undefined;
-        out.push(v);
-    }
-    return out.length > 0 ? out : undefined;
-}
-export function extractAllowedValuesFromText(typeText) {
-    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;
-}
-export function extractJsdocText(comments) {
-    if (!comments.length)
-        return undefined;
-    const last = comments[comments.length - 1];
-    if (last.type !== 'Block')
-        return undefined;
-    const text = last.value
-        .split('\n')
-        .map((l) => l.replace(/^\s*\*\s?/, '').trim())
-        .filter(Boolean)
-        .join(' ')
-        .trim();
-    return text || undefined;
-}

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-dts-location.d.ts

@@ -1 +0,0 @@
-export declare function locateDtsForSpecifier(req: NodeJS.Require, specifier: string, parentFile: string): string | null;

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-dts-location.js

@@ -1,90 +0,0 @@
-import { dirname, join, resolve } from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
-function extractTypesFromExports(exportsField) {
-    if (!exportsField || typeof exportsField !== 'object')
-        return null;
-    const exp = exportsField;
-    const root = (exp['.'] ?? exp);
-    if (!root || typeof root !== 'object')
-        return null;
-    const r = root;
-    if (typeof r['types'] === 'string')
-        return r['types'];
-    for (const key of ['import', 'default', 'node']) {
-        const sub = r[key];
-        if (sub && typeof sub === 'object') {
-            const t = sub['types'];
-            if (typeof t === 'string')
-                return t;
-        }
-    }
-    return null;
-}
-function findPackageRootForSpecifier(seedDir, specifier) {
-    let dir = seedDir;
-    for (let i = 0; i < 32; i++) {
-        if (existsSync(join(dir, 'package.json'))) {
-            try {
-                const pkgRaw = readFileSync(join(dir, 'package.json'), 'utf-8');
-                const pkg = JSON.parse(pkgRaw);
-                if (pkg.name === specifier)
-                    return dir;
-                if (pkg.name && specifier.startsWith(`${pkg.name}/`))
-                    return dir;
-            }
-            catch { }
-        }
-        const parent = dirname(dir);
-        if (!parent || parent === dir)
-            return null;
-        dir = parent;
-    }
-    return null;
-}
-export function locateDtsForSpecifier(req, specifier, parentFile) {
-    let resolvedJs = null;
-    try {
-        resolvedJs = req.resolve(specifier);
-    }
-    catch {
-        resolvedJs = null;
-    }
-    const seedDir = resolvedJs ? dirname(resolvedJs) : dirname(parentFile);
-    const pkgRoot = findPackageRootForSpecifier(seedDir, specifier);
-    if (pkgRoot) {
-        const pkgJsonPath = join(pkgRoot, 'package.json');
-        if (existsSync(pkgJsonPath)) {
-            try {
-                const pkgRaw = readFileSync(pkgJsonPath, 'utf-8');
-                const pkg = JSON.parse(pkgRaw);
-                const typesField = pkg.types ?? pkg.typings;
-                if (typeof typesField === 'string') {
-                    const candidate = resolve(pkgRoot, typesField);
-                    if (existsSync(candidate))
-                        return candidate;
-                }
-                const exportsTypes = extractTypesFromExports(pkg.exports);
-                if (exportsTypes) {
-                    const candidate = resolve(pkgRoot, exportsTypes);
-                    if (existsSync(candidate))
-                        return candidate;
-                }
-            }
-            catch { }
-        }
-        for (const entry of ['index.d.ts', 'index.d.mts']) {
-            const candidate = join(pkgRoot, entry);
-            if (existsSync(candidate))
-                return candidate;
-        }
-    }
-    if (resolvedJs) {
-        const noExt = resolvedJs.replace(/\.(m?js|cjs)$/, '');
-        for (const ext of ['.d.ts', '.d.mts']) {
-            const candidate = `${noExt}${ext}`;
-            if (existsSync(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-allowed-components.d.ts

@@ -1,2 +0,0 @@
-import type { RawComponentDefinition } from '../../../types/component.js';
-export declare function resolveAllowedComponents(components: RawComponentDefinition[]): void;

package/dist/src/extract/framework-adapters/svelte/helpers/resolve-svelte-allowed-components.js

@@ -1,20 +0,0 @@
-import { extractAllowedComponentsFromTypeText } from '../../../helpers/evidence/collect-allowed-component-names.js';
-import { buildComponentLookupMaps } from '../../shared/helpers/build-component-lookup-maps.js';
-export function resolveAllowedComponents(components) {
-    const { propsToComponent, componentNames } = buildComponentLookupMaps(components);
-    for (const c of components) {
-        for (const slot of c.slots) {
-            const raw = slot._rawTypeText;
-            if (raw) {
-                const found = extractAllowedComponentsFromTypeText(raw, {
-                    propsToComponent,
-                    componentNames,
-                });
-                if (found.length > 0)
-                    slot.allowedComponents = found;
-            }
-            delete slot._rawTypeText;
-        }
-        delete c._propsTypeName;
-    }
-}

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

@@ -1,3 +0,0 @@
-import type { AstNode } from '../types/svelte-ast-node.js';
-import type { ResolvedTypeMember } from './extract-svelte-ast-type-members.js';
-export declare function resolveImportedTypeMembers(typeName: string, instance: AstNode, filePath: string): Promise<ResolvedTypeMember[] | null>;

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

@@ -1,68 +0,0 @@
-import { Node, Project, ScriptTarget, ModuleKind } from 'ts-morph';
-import { resolveLocalModule } from '../../shared/helpers/resolve-import-file-path.js';
-import { collectSnippetLocalsFromSourceFile, readInterfaceMembers, readTypeLiteralMembers, } from './extract-svelte-external-type-members.js';
-function readMembersFromExternalFile(filePath, exportName) {
-    const project = new Project({
-        compilerOptions: {
-            strict: false,
-            target: ScriptTarget.ESNext,
-            module: ModuleKind.ESNext,
-            allowJs: true,
-        },
-        useInMemoryFileSystem: false,
-        skipAddingFilesFromTsConfig: true,
-    });
-    const sf = project.addSourceFileAtPathIfExists(filePath);
-    if (!sf)
-        return null;
-    const snippetLocals = collectSnippetLocalsFromSourceFile(sf);
-    const decls = sf.getExportedDeclarations().get(exportName);
-    if (!decls || decls.length === 0)
-        return null;
-    for (const decl of decls) {
-        if (Node.isInterfaceDeclaration(decl)) {
-            const declSf = decl.getSourceFile();
-            return readInterfaceMembers(decl, declSf === sf ? snippetLocals : collectSnippetLocalsFromSourceFile(declSf));
-        }
-        if (Node.isTypeAliasDeclaration(decl)) {
-            const typeNode = decl.getTypeNode();
-            if (typeNode && Node.isTypeLiteral(typeNode)) {
-                const declSf = decl.getSourceFile();
-                return readTypeLiteralMembers(typeNode, declSf === sf ? snippetLocals : collectSnippetLocalsFromSourceFile(declSf));
-            }
-        }
-    }
-    return null;
-}
-export 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 = resolveLocalModule(filePath, specifierValue, {
-            allowJavaScriptExtensionFallback: true,
-        });
-        if (!resolvedFile)
-            continue;
-        return readMembersFromExternalFile(resolvedFile, importedExport);
-    }
-    return null;
-}

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

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

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

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

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

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

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

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

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

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