@contentful/experience-design-system-extraction 2.36.2-dev-build-a6f80ae6.0 → 2.36.2-dev-build-7907fec3.0

package/dist/src/extract/framework-adapters/vue-tsx/helpers/extract-vue-tsx-slots.js

@@ -0,0 +1,91 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getTypeTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
+function extractTypeMemberSlots(members, allowMethods) {
+    return members
+        .flatMap((member) => {
+        if (!Node.isPropertySignature(member) && (!allowMethods || !Node.isMethodSignature(member)))
+            return [];
+        const slotName = member.getName();
+        return [{ name: slotName, isDefault: slotName === 'default' }];
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+function extractSlotsFromTypeNode(typeNode, seen) {
+    if (!typeNode || seen.has(typeNode))
+        return [];
+    seen.add(typeNode);
+    if (Node.isTypeLiteral(typeNode)) {
+        return extractTypeMemberSlots(typeNode.getMembers(), false);
+    }
+    if (Node.isTypeReference(typeNode)) {
+        for (const declaration of getTypeTargetDeclarations(typeNode.getTypeName(), false)) {
+            if (Node.isTypeAliasDeclaration(declaration)) {
+                return extractSlotsFromTypeNode(declaration.getTypeNode(), seen);
+            }
+            if (Node.isInterfaceDeclaration(declaration)) {
+                return extractTypeMemberSlots(declaration.getMembers(), true);
+            }
+        }
+    }
+    return [];
+}
+function extractSlotsFromSetupFunction(options) {
+    const setupProp = options.getProperty('setup');
+    if (!setupProp)
+        return [];
+    const setupFunction = Node.isMethodDeclaration(setupProp)
+        ? setupProp
+        : Node.isPropertyAssignment(setupProp)
+            ? setupProp.getInitializer()
+            : undefined;
+    if (!setupFunction)
+        return [];
+    if (!Node.isMethodDeclaration(setupFunction) &&
+        !Node.isArrowFunction(setupFunction) &&
+        !Node.isFunctionExpression(setupFunction)) {
+        return [];
+    }
+    const params = setupFunction.getParameters();
+    if (params.length < 2)
+        return [];
+    const contextParam = params[1];
+    const nameNode = contextParam.getNameNode();
+    if (!Node.isObjectBindingPattern(nameNode))
+        return [];
+    const slotsBinding = nameNode
+        .getElements()
+        .find((el) => el.getPropertyNameNode()?.getText() === 'slots' || el.getName() === 'slots');
+    if (!slotsBinding)
+        return [];
+    const slotsName = slotsBinding.getName();
+    const body = setupFunction.getBody();
+    if (!body)
+        return [];
+    const slotsByName = new Map();
+    for (const access of body.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
+        if (access.getExpression().getText() !== slotsName)
+            continue;
+        const slotName = access.getName();
+        if (!slotsByName.has(slotName)) {
+            slotsByName.set(slotName, {
+                name: slotName,
+                isDefault: slotName === 'default',
+            });
+        }
+    }
+    return [...slotsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Extracts slots from a `defineComponent` options object, preferring type-level declarations over setup access. */
+export function extractVueTsxComponentSlots(options, slotsTypeNode) {
+    const slotsByName = new Map();
+    if (slotsTypeNode) {
+        for (const slot of extractSlotsFromTypeNode(slotsTypeNode, new Set())) {
+            slotsByName.set(slot.name, slot);
+        }
+    }
+    for (const slot of extractSlotsFromSetupFunction(options)) {
+        if (!slotsByName.has(slot.name))
+            slotsByName.set(slot.name, slot);
+    }
+    return [...slotsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/extract/framework-adapters/vue-tsx/helpers/resolve-ast-object.d.ts

@@ -0,0 +1,11 @@
+import { Node } from 'ts-morph';
+/** Recursively resolves a node to the object literal it represents or returns, or undefined. */
+export declare function resolveReturnedObjectLiteral(node: Node, seen: Set<Node>): import('ts-morph').ObjectLiteralExpression | undefined;
+/** Scans a list of statements for a `return <object literal>` and resolves it. */
+export declare function resolveObjectLiteralFromStatements(statements: import('ts-morph').Statement[], seen: Set<Node>): import('ts-morph').ObjectLiteralExpression | undefined;
+/** Resolves a call expression's callee to an object literal it returns. */
+export declare function resolveObjectLiteralFromCallExpression(callExpression: import('ts-morph').CallExpression, seen: Set<Node>): import('ts-morph').ObjectLiteralExpression | undefined;
+/** Returns the trailing identifier name from an expression (e.g. `foo.bar` → `'bar'`). */
+export declare function getExpressionTerminalName(node: Node): string | undefined;
+/** Extracts an array of string literal values, or returns undefined if any element is not a string literal. */
+export declare function extractStringArrayLiteralValues(node: Node): string[] | undefined;

package/dist/src/extract/framework-adapters/vue-tsx/helpers/resolve-ast-object.js

@@ -0,0 +1,95 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getValueTargetDeclarations } from '../../shared/helpers/tsx-shared.js';
+/** Recursively resolves a node to the object literal it represents or returns, or undefined. */
+export function resolveReturnedObjectLiteral(node, seen) {
+    if (seen.has(node))
+        return undefined;
+    seen.add(node);
+    if (Node.isObjectLiteralExpression(node))
+        return node;
+    if (Node.isParenthesizedExpression(node)) {
+        return resolveReturnedObjectLiteral(node.getExpression(), seen);
+    }
+    if (Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (!initializer)
+            return undefined;
+        return resolveReturnedObjectLiteral(initializer, seen);
+    }
+    if (Node.isArrowFunction(node)) {
+        const body = node.getBody();
+        if (Node.isObjectLiteralExpression(body))
+            return body;
+        const block = body.asKind(SyntaxKind.Block);
+        if (block)
+            return resolveObjectLiteralFromStatements(block.getStatements(), seen);
+        return resolveReturnedObjectLiteral(body, seen);
+    }
+    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node)) {
+        const body = node.getBody();
+        if (!body)
+            return undefined;
+        const block = body.asKind(SyntaxKind.Block);
+        if (!block)
+            return undefined;
+        return resolveObjectLiteralFromStatements(block.getStatements(), seen);
+    }
+    if (Node.isCallExpression(node)) {
+        return resolveObjectLiteralFromCallExpression(node, seen);
+    }
+    if (Node.isIdentifier(node)) {
+        for (const declaration of getValueTargetDeclarations(node)) {
+            const resolved = resolveReturnedObjectLiteral(declaration, seen);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}
+/** Scans a list of statements for a `return <object literal>` and resolves it. */
+export function resolveObjectLiteralFromStatements(statements, seen) {
+    for (const statement of statements) {
+        if (!Node.isReturnStatement(statement))
+            continue;
+        const expression = statement.getExpression();
+        if (!expression)
+            continue;
+        const resolved = resolveReturnedObjectLiteral(expression, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+/** Resolves a call expression's callee to an object literal it returns. */
+export function resolveObjectLiteralFromCallExpression(callExpression, seen) {
+    const expression = callExpression.getExpression();
+    if (!Node.isIdentifier(expression))
+        return undefined;
+    for (const declaration of getValueTargetDeclarations(expression)) {
+        const resolved = resolveReturnedObjectLiteral(declaration, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+/** Returns the trailing identifier name from an expression (e.g. `foo.bar` → `'bar'`). */
+export function getExpressionTerminalName(node) {
+    if (Node.isIdentifier(node))
+        return node.getText();
+    if (Node.isPropertyAccessExpression(node))
+        return node.getName();
+    return undefined;
+}
+/** Extracts an array of string literal values, or returns undefined if any element is not a string literal. */
+export function extractStringArrayLiteralValues(node) {
+    if (!Node.isArrayLiteralExpression(node))
+        return undefined;
+    const keys = [];
+    for (const element of node.getElements()) {
+        if (!Node.isStringLiteral(element) && !Node.isNoSubstitutionTemplateLiteral(element)) {
+            return undefined;
+        }
+        keys.push(element.getLiteralText());
+    }
+    return keys;
+}

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

@@ -1,2 +1,2 @@
-import type { ComponentExtractionResult } from '../types.js';
+import type { ComponentExtractionResult } from '../../types/component.js';
 export declare function extractWebComponentDefinitions(filePaths: string[]): Promise<ComponentExtractionResult>;

package/dist/src/extract/framework-adapters/web-components/extractor.js

@@ -0,0 +1,55 @@
+import { Project } from 'ts-morph';
+import { createSortedExtractionResult } from '../shared/helpers/file-processing/result-normalizer.js';
+import { extractProjectSourceFiles } from '../shared/helpers/file-processing/project-source-files.js';
+import { extractAccessorProperties, extractClassProperties, extractJsDocAttributeProps, extractObservedAttributes, mergePropLists, mergeProps, } from './helpers/merge-wc-prop-lists.js';
+import { buildTagNameMap, chooseComponentName, resolveWcTagName } from './helpers/resolve-wc-tag-name.js';
+import { extractSlotsFromTemplate, mergeSlotLists, extractJsDocSlots, extractTemplateContent, extractFastTemplateSlots, } from './helpers/extract-wc-slots.js';
+import { extractInheritedClassProperties, extractInheritedSlots } from './helpers/extract-wc-inheritance.js';
+function extractFromSourceFile(sourceFile, project) {
+    const components = [];
+    const tagNameMap = buildTagNameMap(sourceFile);
+    for (const classDecl of sourceFile.getClasses()) {
+        const className = classDecl.getName();
+        if (!className)
+            continue;
+        const tagName = resolveWcTagName(classDecl, tagNameMap, project);
+        if (!tagName)
+            continue;
+        const name = chooseComponentName(classDecl, className, tagName);
+        const observedAttrs = extractObservedAttributes(classDecl);
+        const inheritedProps = extractInheritedClassProperties(classDecl, project);
+        const classProps = mergePropLists(extractJsDocAttributeProps(classDecl), extractAccessorProperties(classDecl), extractClassProperties(classDecl));
+        const props = mergeProps(observedAttrs, mergePropLists(inheritedProps, classProps));
+        const templateContent = extractTemplateContent(classDecl, project);
+        const slots = mergeSlotLists(extractInheritedSlots(classDecl, project), extractJsDocSlots(classDecl), extractSlotsFromTemplate(templateContent), extractFastTemplateSlots(classDecl, project));
+        components.push({
+            name,
+            source: sourceFile.getFilePath(),
+            sourcePath: sourceFile.getFilePath(),
+            framework: 'web-component',
+            props,
+            slots,
+        });
+    }
+    return components;
+}
+export async function extractWebComponentDefinitions(filePaths) {
+    const tsFiles = filePaths.filter((f) => /\.[jt]s$/.test(f) && !f.endsWith('.d.ts'));
+    if (tsFiles.length === 0) {
+        return { components: [], warnings: [] };
+    }
+    const project = new Project({
+        compilerOptions: {
+            target: 99,
+            module: 99,
+            moduleResolution: 100,
+            skipLibCheck: true,
+        },
+        skipAddingFilesFromTsConfig: true,
+    });
+    for (const filePath of tsFiles) {
+        project.addSourceFileAtPath(filePath);
+    }
+    const { items: components, warnings } = extractProjectSourceFiles(project, (sourceFile) => extractFromSourceFile(sourceFile, project));
+    return createSortedExtractionResult(components, warnings);
+}

package/dist/src/extract/framework-adapters/web-components/helpers/collect-wc-html-templates.d.ts

@@ -0,0 +1,4 @@
+import { Node, type Project } from 'ts-morph';
+export declare function collectHtmlTaggedTemplates(root: Node): string[];
+export declare function resolveTemplateHelperDeclarations(callExpression: import('ts-morph').CallExpression, project: Project): Node[];
+export declare function collectHtmlTaggedTemplatesWithHelpers(root: Node, project: Project): string[];

package/dist/src/extract/framework-adapters/web-components/helpers/collect-wc-html-templates.js

@@ -0,0 +1,67 @@
+import { Node } from 'ts-morph';
+import { loadSourceFile, resolveImportSourcePath } from './resolve-wc-import.js';
+export function collectHtmlTaggedTemplates(root) {
+    const templates = [];
+    root.forEachDescendant((node) => {
+        if (!Node.isTaggedTemplateExpression(node))
+            return;
+        const tag = node.getTag();
+        if (tag.getText() !== 'html')
+            return;
+        const template = node.getTemplate();
+        if (Node.isNoSubstitutionTemplateLiteral(template) || Node.isTemplateExpression(template)) {
+            templates.push(template.getText().slice(1, -1));
+        }
+    });
+    return templates;
+}
+export function resolveTemplateHelperDeclarations(callExpression, project) {
+    const expression = callExpression.getExpression();
+    if (!Node.isIdentifier(expression))
+        return [];
+    const declarations = [];
+    for (const definition of expression.getDefinitions()) {
+        const declarationNode = definition.getDeclarationNode();
+        if (!declarationNode)
+            continue;
+        if (Node.isFunctionDeclaration(declarationNode) || Node.isVariableDeclaration(declarationNode)) {
+            declarations.push(declarationNode);
+            continue;
+        }
+        if (!Node.isImportSpecifier(declarationNode))
+            continue;
+        const importDecl = declarationNode.getImportDeclaration();
+        const resolvedImportPath = resolveImportSourcePath(callExpression.getSourceFile().getFilePath(), importDecl.getModuleSpecifierValue());
+        if (!resolvedImportPath)
+            continue;
+        const importedFile = loadSourceFile(project, resolvedImportPath);
+        if (!importedFile)
+            continue;
+        const importedName = declarationNode.getNameNode().getText();
+        const importedFunction = importedFile.getFunction(importedName);
+        if (importedFunction) {
+            declarations.push(importedFunction);
+            continue;
+        }
+        const importedVariable = importedFile.getVariableDeclaration(importedName);
+        if (importedVariable)
+            declarations.push(importedVariable);
+    }
+    return declarations;
+}
+export function collectHtmlTaggedTemplatesWithHelpers(root, project) {
+    const templates = [...collectHtmlTaggedTemplates(root)];
+    const seenTemplateHelpers = new Set();
+    root.forEachDescendant((node) => {
+        if (!Node.isCallExpression(node))
+            return;
+        for (const declaration of resolveTemplateHelperDeclarations(node, project)) {
+            const helperKey = `${declaration.getSourceFile().getFilePath()}:${declaration.getStart()}`;
+            if (seenTemplateHelpers.has(helperKey))
+                continue;
+            seenTemplateHelpers.add(helperKey);
+            templates.push(...collectHtmlTaggedTemplates(declaration));
+        }
+    });
+    return templates;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/detect-wc-non-public-members.d.ts

@@ -0,0 +1,9 @@
+export declare function hasInternalJsDocTag(member: {
+    getJsDocs(): import('ts-morph').JSDoc[];
+}): boolean;
+export declare const NON_PUBLIC_LIT_DECORATORS: Set<string>;
+export declare const INTERNAL_RUNTIME_FIELD_NAMES: Set<string>;
+export declare function isNonPublicLitMember(member: {
+    getDecorators(): import('ts-morph').Decorator[];
+}): boolean;
+export declare function isInternalRuntimeField(name: string, applyRuntimeFieldDenylist: boolean): boolean;

package/dist/src/extract/framework-adapters/web-components/helpers/detect-wc-non-public-members.js

@@ -0,0 +1,11 @@
+export function hasInternalJsDocTag(member) {
+    return member.getJsDocs().some((doc) => doc.getTags().some((tag) => tag.getTagName() === 'internal'));
+}
+export const NON_PUBLIC_LIT_DECORATORS = new Set(['consume', 'provide', 'query', 'queryAsync', 'state']);
+export const INTERNAL_RUNTIME_FIELD_NAMES = new Set(['dir', 'initialReflectedProperties', 'lang']);
+export function isNonPublicLitMember(member) {
+    return member.getDecorators().some((decorator) => NON_PUBLIC_LIT_DECORATORS.has(decorator.getName()));
+}
+export function isInternalRuntimeField(name, applyRuntimeFieldDenylist) {
+    return applyRuntimeFieldDenylist && INTERNAL_RUNTIME_FIELD_NAMES.has(name);
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-accessor-props.d.ts

@@ -0,0 +1,3 @@
+import { type ClassDeclaration } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractAccessorProperties(classDecl: ClassDeclaration, applyRuntimeFieldDenylist?: boolean): RawPropDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-accessor-props.js

@@ -0,0 +1,65 @@
+import { hasInternalJsDocTag, isNonPublicLitMember, isInternalRuntimeField } from './detect-wc-non-public-members.js';
+export function extractAccessorProperties(classDecl, applyRuntimeFieldDenylist = false) {
+    const props = [];
+    const accessors = new Map();
+    for (const getter of classDecl.getGetAccessors()) {
+        if (getter.isStatic())
+            continue;
+        if (hasInternalJsDocTag(getter))
+            continue;
+        if (isNonPublicLitMember(getter))
+            continue;
+        const name = getter.getName();
+        if (name === 'observedAttributes' ||
+            name === 'template' ||
+            name.startsWith('#') ||
+            isInternalRuntimeField(name, applyRuntimeFieldDenylist))
+            continue;
+        const scope = getter.getScope();
+        if (scope === 'private' || scope === 'protected')
+            continue;
+        const entry = accessors.get(name) ?? {};
+        entry.getter = getter;
+        accessors.set(name, entry);
+    }
+    for (const setter of classDecl.getSetAccessors()) {
+        if (setter.isStatic())
+            continue;
+        if (hasInternalJsDocTag(setter))
+            continue;
+        if (isNonPublicLitMember(setter))
+            continue;
+        const name = setter.getName();
+        if (name === 'observedAttributes' ||
+            name === 'template' ||
+            name.startsWith('#') ||
+            isInternalRuntimeField(name, applyRuntimeFieldDenylist))
+            continue;
+        const scope = setter.getScope();
+        if (scope === 'private' || scope === 'protected')
+            continue;
+        const entry = accessors.get(name) ?? {};
+        entry.setter = setter;
+        accessors.set(name, entry);
+    }
+    for (const [name, { getter, setter }] of accessors) {
+        const hasPropertyDecorator = getter?.getDecorators().some((decorator) => decorator.getName() === 'property') ||
+            setter?.getDecorators().some((decorator) => decorator.getName() === 'property');
+        if (!hasPropertyDecorator && !(getter && setter))
+            continue;
+        const type = getter?.getReturnTypeNode()?.getText() ?? setter?.getParameters()[0]?.getTypeNode()?.getText() ?? 'any';
+        const accessorNode = getter ?? setter;
+        props.push({
+            name,
+            type,
+            required: false,
+            ...(accessorNode
+                ? {
+                    sourceStartLine: accessorNode.getStartLineNumber(),
+                    sourceEndLine: accessorNode.getEndLineNumber(),
+                }
+                : {}),
+        });
+    }
+    return props;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-class-properties.d.ts

@@ -0,0 +1,3 @@
+import { type ClassDeclaration } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractClassProperties(classDecl: ClassDeclaration, applyRuntimeFieldDenylist?: boolean): RawPropDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-class-properties.js

@@ -0,0 +1,60 @@
+import { Node } from 'ts-morph';
+import { hasInternalJsDocTag, isNonPublicLitMember, isInternalRuntimeField } from './detect-wc-non-public-members.js';
+function kebabToCamel(input) {
+    return input.replace(/-([a-z0-9])/gi, (_, char) => char.toUpperCase());
+}
+function getExplicitLitPropertyAttributeName(property) {
+    const decorator = property.getDecorators().find((candidate) => candidate.getName() === 'property');
+    const firstArg = decorator?.getArguments()[0];
+    if (!firstArg || !Node.isObjectLiteralExpression(firstArg))
+        return null;
+    const attributeProp = firstArg.getProperty('attribute');
+    if (!attributeProp || !Node.isPropertyAssignment(attributeProp))
+        return null;
+    const initializer = attributeProp.getInitializer();
+    if (!initializer || !Node.isStringLiteral(initializer))
+        return null;
+    return initializer.getLiteralValue();
+}
+export function extractClassProperties(classDecl, applyRuntimeFieldDenylist = false) {
+    const props = [];
+    for (const property of classDecl.getProperties()) {
+        if (property.isStatic())
+            continue;
+        if (hasInternalJsDocTag(property))
+            continue;
+        if (isNonPublicLitMember(property))
+            continue;
+        const name = property.getName();
+        if (name.startsWith('#') || isInternalRuntimeField(name, applyRuntimeFieldDenylist))
+            continue;
+        const scope = property.getScope();
+        if (scope === 'private' || scope === 'protected')
+            continue;
+        const initializer = property.getInitializer();
+        const hasDecorators = property.getDecorators().length > 0;
+        if (!hasDecorators && initializer && Node.isArrowFunction(initializer))
+            continue;
+        if (initializer &&
+            Node.isCallExpression(initializer) &&
+            initializer.getExpression().getText() === 'this.attachInternals') {
+            continue;
+        }
+        const typeNode = property.getTypeNode();
+        const type = typeNode ? typeNode.getText() : 'any';
+        const publicName = name.startsWith('_') && hasDecorators ? getExplicitLitPropertyAttributeName(property) : null;
+        let defaultValue;
+        if (initializer) {
+            defaultValue = Node.isStringLiteral(initializer) ? initializer.getLiteralValue() : initializer.getText();
+        }
+        props.push({
+            name: publicName ? kebabToCamel(publicName) : name,
+            type,
+            required: false,
+            ...(defaultValue !== undefined && { defaultValue }),
+            sourceStartLine: property.getStartLineNumber(),
+            sourceEndLine: property.getEndLineNumber(),
+        });
+    }
+    return props;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-inheritance.d.ts

@@ -0,0 +1,4 @@
+import { type ClassDeclaration, type Project } from 'ts-morph';
+import type { RawPropDefinition, RawSlotDefinition } from '../../../types/component.js';
+export declare function extractInheritedClassProperties(classDecl: ClassDeclaration, project: Project, visitedFiles?: Set<string>, applyRuntimeFieldDenylist?: boolean): RawPropDefinition[];
+export declare function extractInheritedSlots(classDecl: ClassDeclaration, project: Project, visitedFiles?: Set<string>): RawSlotDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-inheritance.js

@@ -0,0 +1,16 @@
+import { extractAccessorProperties, extractClassProperties, extractJsDocAttributeProps, hasShoelaceRuntimeBookkeepingField, mergePropLists, } from './merge-wc-prop-lists.js';
+import { mergeSlotLists, extractJsDocSlots } from './extract-wc-slots.js';
+import { getImportedBaseClass } from './resolve-wc-base-class.js';
+export function extractInheritedClassProperties(classDecl, project, visitedFiles = new Set(), applyRuntimeFieldDenylist = false) {
+    const baseClass = getImportedBaseClass(classDecl, project, visitedFiles);
+    if (!baseClass)
+        return [];
+    const nextApplyRuntimeFieldDenylist = applyRuntimeFieldDenylist || hasShoelaceRuntimeBookkeepingField(baseClass);
+    return mergePropLists(extractInheritedClassProperties(baseClass, project, visitedFiles, nextApplyRuntimeFieldDenylist), extractJsDocAttributeProps(baseClass), extractAccessorProperties(baseClass, nextApplyRuntimeFieldDenylist), extractClassProperties(baseClass, nextApplyRuntimeFieldDenylist));
+}
+export function extractInheritedSlots(classDecl, project, visitedFiles = new Set()) {
+    const baseClass = getImportedBaseClass(classDecl, project, visitedFiles);
+    if (!baseClass)
+        return [];
+    return mergeSlotLists(extractInheritedSlots(baseClass, project, visitedFiles), extractJsDocSlots(baseClass));
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-jsdoc-attr-props.d.ts

@@ -0,0 +1,3 @@
+import type { ClassDeclaration } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractJsDocAttributeProps(classDecl: ClassDeclaration): RawPropDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-jsdoc-attr-props.js

@@ -0,0 +1,24 @@
+export function extractJsDocAttributeProps(classDecl) {
+    const props = [];
+    for (const doc of classDecl.getJsDocs()) {
+        for (const tag of doc.getTags()) {
+            if (tag.getTagName() !== 'attribute')
+                continue;
+            const tagComment = tag.getCommentText();
+            const normalizedComment = Array.isArray(tagComment) ? tagComment.join(' ') : tagComment;
+            const match = normalizedComment?.match(/(?:\{([^}]+)\}\s+)?([^\s]+)(?:\s*-\s*([\s\S]*))?/);
+            if (!match)
+                continue;
+            const [, type, name, description] = match;
+            if (!name || name.startsWith('#'))
+                continue;
+            props.push({
+                name,
+                type: type?.trim() || 'any',
+                required: false,
+                ...(description ? { description: description.replace(/\s+/g, ' ').trim() } : {}),
+            });
+        }
+    }
+    return props;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-observed-attrs.d.ts

@@ -0,0 +1,3 @@
+import { type ClassDeclaration } from 'ts-morph';
+import type { RawPropDefinition } from '../../../types/component.js';
+export declare function extractObservedAttributes(classDecl: ClassDeclaration): RawPropDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-observed-attrs.js

@@ -0,0 +1,27 @@
+import { Node } from 'ts-morph';
+export function extractObservedAttributes(classDecl) {
+    const props = [];
+    const getter = classDecl.getGetAccessor('observedAttributes');
+    if (!getter || !getter.isStatic())
+        return props;
+    const body = getter.getBody();
+    if (!body)
+        return props;
+    body.forEachDescendant((node) => {
+        if (!Node.isReturnStatement(node))
+            return;
+        const expression = node.getExpression();
+        if (!expression || !Node.isArrayLiteralExpression(expression))
+            return;
+        for (const element of expression.getElements()) {
+            if (Node.isStringLiteral(element)) {
+                props.push({
+                    name: element.getLiteralValue(),
+                    type: 'string',
+                    required: false,
+                });
+            }
+        }
+    });
+    return props;
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-slots.d.ts

@@ -0,0 +1,6 @@
+import { type ClassDeclaration } from 'ts-morph';
+import type { RawSlotDefinition } from '../../../types/component.js';
+export { extractTemplateContent, extractFastTemplateSlots } from './extract-wc-template-content.js';
+export declare function extractSlotsFromTemplate(templateContent: string): RawSlotDefinition[];
+export declare function mergeSlotLists(...slotLists: RawSlotDefinition[][]): RawSlotDefinition[];
+export declare function extractJsDocSlots(classDecl: ClassDeclaration): RawSlotDefinition[];

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-slots.js

@@ -0,0 +1,56 @@
+import { collectJsDocSlotComments } from '../../shared/helpers/collect-jsdoc-slot-comments.js';
+export { extractTemplateContent, extractFastTemplateSlots } from './extract-wc-template-content.js';
+export function extractSlotsFromTemplate(templateContent) {
+    const slots = new Map();
+    const slotRegex = /<slot\b([^>]*)>/g;
+    for (const match of templateContent.matchAll(slotRegex)) {
+        const attrs = match[1] ?? '';
+        const nameMatch = attrs.match(/\bname=["']([^"']+)["']/);
+        const name = nameMatch?.[1] ?? 'default';
+        slots.set(name, name === 'default');
+    }
+    return [...slots.entries()]
+        .map(([name, isDefault]) => ({ name, isDefault }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function mergeSlotLists(...slotLists) {
+    const merged = new Map();
+    for (const slotList of slotLists) {
+        for (const slot of slotList) {
+            const existing = merged.get(slot.name);
+            if (!existing) {
+                merged.set(slot.name, slot);
+                continue;
+            }
+            merged.set(slot.name, {
+                ...existing,
+                ...slot,
+                description: existing.description ?? slot.description,
+            });
+        }
+    }
+    return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function extractJsDocSlots(classDecl) {
+    const slots = [];
+    for (const comment of collectJsDocSlotComments(classDecl)) {
+        let name = 'default';
+        let description = comment;
+        if (comment.startsWith('-')) {
+            description = comment.slice(1).trim();
+        }
+        else {
+            const match = comment.match(/^(\S+)\s*-\s*(.*)$/s);
+            if (match) {
+                name = match[1];
+                description = match[2].trim();
+            }
+        }
+        slots.push({
+            name,
+            isDefault: name === 'default',
+            ...(description && { description }),
+        });
+    }
+    return mergeSlotLists(slots);
+}

package/dist/src/extract/framework-adapters/web-components/helpers/extract-wc-template-content.d.ts

@@ -0,0 +1,4 @@
+import { type ClassDeclaration, type Project } from 'ts-morph';
+import type { RawSlotDefinition } from '../../../types/component.js';
+export declare function extractTemplateContent(classDecl: ClassDeclaration, project: Project): string;
+export declare function extractFastTemplateSlots(classDecl: ClassDeclaration, project: Project): RawSlotDefinition[];