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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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