@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/react/helpers/infer-primitive-dom-props.js

@@ -0,0 +1,69 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { getJsxTagNameNode } from '../../shared/helpers/tsx-shared.js';
+import { getDomAttributeSurface, JSX_PRIMITIVE_DOM_ATTRIBUTE_SURFACES, getBoundedImportedJsxDomSurface, } from './dom-attribute-surfaces.js';
+export function collectRestBindingNames(nameNode) {
+    const names = new Set();
+    if (!Node.isObjectBindingPattern(nameNode))
+        return names;
+    for (const element of nameNode.getElements()) {
+        if (!element.getDotDotDotToken())
+            continue;
+        const restNameNode = element.getNameNode();
+        if (Node.isIdentifier(restNameNode))
+            names.add(restNameNode.getText());
+    }
+    return names;
+}
+export function isComponentSpreadAttribute(attribute, bindingNames) {
+    if (!Node.isJsxSpreadAttribute(attribute))
+        return false;
+    const expression = attribute.getExpression();
+    if (!Node.isIdentifier(expression) || !bindingNames.has(expression.getText()))
+        return false;
+    const tagName = getJsxTagNameNode(attribute)?.getText();
+    return tagName ? /^[A-Z]/.test(tagName) : false;
+}
+export function inferPrimitiveDomPropsFromImplementation(funcNode, propsParam) {
+    const candidatePropNames = new Set();
+    const propsParamNameNode = propsParam.getNameNode();
+    if (Node.isIdentifier(propsParamNameNode))
+        candidatePropNames.add(propsParam.getName());
+    for (const restName of collectRestBindingNames(propsParamNameNode))
+        candidatePropNames.add(restName);
+    for (const variableDeclaration of funcNode.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+        const initializer = variableDeclaration.getInitializer();
+        if (!initializer || !Node.isIdentifier(initializer) || !candidatePropNames.has(initializer.getText()))
+            continue;
+        const nameNode = variableDeclaration.getNameNode();
+        if (!Node.isObjectBindingPattern(nameNode))
+            continue;
+        for (const restName of collectRestBindingNames(nameNode))
+            candidatePropNames.add(restName);
+    }
+    if (candidatePropNames.size === 0)
+        return [];
+    const inferredSurfaces = new Set();
+    const jsxElements = [
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ];
+    for (const jsxElement of jsxElements) {
+        const tagNameNode = jsxElement.getTagNameNode();
+        const domSurface = JSX_PRIMITIVE_DOM_ATTRIBUTE_SURFACES[tagNameNode.getText()] ?? getBoundedImportedJsxDomSurface(tagNameNode);
+        if (!domSurface)
+            continue;
+        const hasForwardedPropsSpread = jsxElement
+            .getAttributes()
+            .some((attribute) => Node.isJsxSpreadAttribute(attribute) &&
+            Node.isIdentifier(attribute.getExpression()) &&
+            candidatePropNames.has(attribute.getExpression().getText()));
+        if (hasForwardedPropsSpread)
+            inferredSurfaces.add(domSurface);
+    }
+    const propsByName = new Map();
+    for (const surface of inferredSurfaces) {
+        for (const prop of getDomAttributeSurface(surface))
+            propsByName.set(prop.name, prop);
+    }
+    return [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/src/extract/framework-adapters/react/helpers/resolve-component-function.d.ts

@@ -0,0 +1,4 @@
+import { Node, type ArrowFunction, type FunctionDeclaration, type FunctionExpression } from 'ts-morph';
+export type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression;
+export declare function resolveFunctionNode(decl: Node): FunctionLike | undefined;
+export declare function resolveBestFunctionNode(declarations: Node[]): FunctionLike | undefined;

package/dist/src/extract/framework-adapters/react/helpers/resolve-component-function.js

@@ -0,0 +1,131 @@
+import { Node, } from 'ts-morph';
+import { getNodeDefinitions } from '../../shared/helpers/tsx-shared.js';
+export function resolveFunctionNode(decl) {
+    if (Node.isFunctionDeclaration(decl))
+        return decl;
+    if (Node.isArrowFunction(decl))
+        return decl;
+    if (Node.isFunctionExpression(decl))
+        return decl;
+    if (Node.isVariableDeclaration(decl)) {
+        const init = decl.getInitializer();
+        if (init && Node.isArrowFunction(init))
+            return init;
+        if (init && Node.isFunctionExpression(init))
+            return init;
+        if (init && Node.isCallExpression(init))
+            return resolveFunctionFromCallExpression(init, new Set());
+    }
+    return undefined;
+}
+export function resolveBestFunctionNode(declarations) {
+    const candidates = declarations
+        .map((decl) => resolveFunctionNode(decl))
+        .filter((candidate) => candidate !== undefined);
+    const implementation = candidates.find((candidate) => !Node.isFunctionDeclaration(candidate) || candidate.getBody() !== undefined);
+    return implementation ?? candidates[0];
+}
+function resolveForwardRefFunction(callExpr) {
+    if (!Node.isCallExpression(callExpr))
+        return undefined;
+    const expressionText = callExpr.getExpression().getText();
+    if (!/(^|\.)forwardRef$/.test(expressionText))
+        return undefined;
+    const firstArg = callExpr.getArguments()[0];
+    if (!firstArg)
+        return undefined;
+    if (Node.isArrowFunction(firstArg))
+        return firstArg;
+    if (Node.isFunctionExpression(firstArg))
+        return firstArg;
+    if (Node.isIdentifier(firstArg)) {
+        const declarations = getNodeDefinitions(firstArg).flatMap((definition) => {
+            const declarationNode = definition.getDeclarationNode();
+            return declarationNode ? [declarationNode] : [];
+        });
+        for (const declaration of declarations) {
+            const resolved = resolveFunctionNode(declaration);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}
+function resolveFunctionFromCallExpression(callExpr, seen) {
+    return resolveForwardRefFunction(callExpr) ?? resolveReturnedFunctionFromFactoryCall(callExpr, seen);
+}
+function resolveReturnedFunctionFromFactoryCall(callExpr, seen) {
+    const expression = callExpr.getExpression();
+    if (!Node.isIdentifier(expression))
+        return undefined;
+    for (const definition of getNodeDefinitions(expression)) {
+        const declaration = definition.getDeclarationNode();
+        if (!declaration)
+            continue;
+        const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromDeclaration(node, seen) {
+    if (seen.has(node))
+        return undefined;
+    seen.add(node);
+    if (Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (!initializer)
+            return undefined;
+        if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
+            return resolveReturnedFunctionFromCallable(initializer, seen);
+        }
+        if (Node.isCallExpression(initializer)) {
+            return resolveFunctionFromCallExpression(initializer, seen);
+        }
+        return undefined;
+    }
+    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
+        return resolveReturnedFunctionFromCallable(node, seen);
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromCallable(fn, seen) {
+    const body = fn.getBody();
+    if (!body)
+        return undefined;
+    if (!Node.isBlock(body)) {
+        return resolveReturnedFunctionFromExpression(body, seen);
+    }
+    for (const statement of body.getStatements()) {
+        if (!Node.isReturnStatement(statement))
+            continue;
+        const expression = statement.getExpression();
+        if (!expression)
+            continue;
+        const resolved = resolveReturnedFunctionFromExpression(expression, seen);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveReturnedFunctionFromExpression(node, seen) {
+    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node))
+        return node;
+    if (Node.isParenthesizedExpression(node)) {
+        return resolveReturnedFunctionFromExpression(node.getExpression(), seen);
+    }
+    if (Node.isCallExpression(node)) {
+        return resolveFunctionFromCallExpression(node, seen);
+    }
+    if (Node.isIdentifier(node)) {
+        for (const definition of getNodeDefinitions(node)) {
+            const declaration = definition.getDeclarationNode();
+            if (!declaration)
+                continue;
+            const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return undefined;
+}

package/dist/src/extract/framework-adapters/react/helpers/resolve-react-prop-forwarding.d.ts

@@ -0,0 +1,8 @@
+import type { RawComponentDefinition } from '../../../types/component.js';
+import type { PropForwardingEdge } from './collect-prop-dataflow.js';
+type ComponentWithIdentity = RawComponentDefinition & {
+    _componentIdentity?: string;
+    _propForwardingEdges?: PropForwardingEdge[];
+};
+export declare function resolveReactPropForwarding(components: ComponentWithIdentity[]): void;
+export {};

package/dist/src/extract/framework-adapters/react/helpers/resolve-react-prop-forwarding.js

@@ -0,0 +1,22 @@
+export function resolveReactPropForwarding(components) {
+    const componentsByIdentity = new Map(components.filter((c) => c._componentIdentity).map((c) => [c._componentIdentity, c]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const component of components) {
+            for (const edge of component._propForwardingEdges ?? []) {
+                const target = componentsByIdentity.get(edge.targetComponentIdentity);
+                const targetProp = target?.props.find((prop) => prop.name === edge.targetProp);
+                const sourceProp = component.props.find((prop) => prop.name === edge.sourceProp);
+                if (targetProp?.domAttribute && sourceProp && !sourceProp.domAttribute) {
+                    sourceProp.domAttribute = true;
+                    changed = true;
+                }
+            }
+        }
+    }
+    for (const component of components) {
+        delete component._componentIdentity;
+        delete component._propForwardingEdges;
+    }
+}

package/dist/src/extract/framework-adapters/react/helpers/resolve-react-props-type.d.ts

@@ -0,0 +1,14 @@
+import { Node, type ParameterDeclaration } from 'ts-morph';
+export declare function normalizePropsTypeNode(typeNode: Node): {
+    typeNode: Node;
+    hasWrappedChildren: boolean;
+    suppressProps: boolean;
+};
+export declare function resolveForwardRefGenericPropsTypeNode(param: ParameterDeclaration): Node | undefined;
+export declare function resolveFCGenericPropsTypeNode(param: ParameterDeclaration): Node | undefined;
+export declare function resolvePropsType(param: ParameterDeclaration): {
+    type: import('ts-morph').Type;
+    typeNode: Node;
+    hasWrappedChildren: boolean;
+    suppressProps: boolean;
+};

package/dist/src/extract/framework-adapters/react/helpers/resolve-react-props-type.js

@@ -0,0 +1,86 @@
+import { Node } from 'ts-morph';
+import { getTypeReferenceName } from '../../shared/helpers/tsx-shared.js';
+import { isPureExpandableDomAttributeWrapperType } from './detect-dom-type-patterns.js';
+const PROP_WRAPPER_TYPE_NAMES = new Set(['ExpandProps']);
+const CHILD_WRAPPER_TYPE_NAMES = new Set(['PropsWithChildren']);
+const FC_TYPE_NAMES = new Set(['FC', 'FunctionComponent', 'VFC', 'VoidFunctionComponent']);
+export function normalizePropsTypeNode(typeNode) {
+    if (!Node.isTypeReference(typeNode)) {
+        return { typeNode, hasWrappedChildren: false, suppressProps: false };
+    }
+    const typeName = getTypeReferenceName(typeNode);
+    if (!typeName) {
+        return { typeNode, hasWrappedChildren: false, suppressProps: false };
+    }
+    if (PROP_WRAPPER_TYPE_NAMES.has(typeName)) {
+        const firstTypeArg = typeNode.getTypeArguments()[0];
+        if (!firstTypeArg)
+            return { typeNode, hasWrappedChildren: false, suppressProps: false };
+        return normalizePropsTypeNode(firstTypeArg);
+    }
+    if (CHILD_WRAPPER_TYPE_NAMES.has(typeName)) {
+        const firstTypeArg = typeNode.getTypeArguments()[0];
+        if (!firstTypeArg)
+            return { typeNode, hasWrappedChildren: true, suppressProps: false };
+        if (isPureExpandableDomAttributeWrapperType(firstTypeArg)) {
+            return {
+                typeNode: firstTypeArg,
+                hasWrappedChildren: true,
+                suppressProps: true,
+            };
+        }
+        const normalized = normalizePropsTypeNode(firstTypeArg);
+        return { ...normalized, hasWrappedChildren: true };
+    }
+    return { typeNode, hasWrappedChildren: false, suppressProps: false };
+}
+export function resolveForwardRefGenericPropsTypeNode(param) {
+    const parent = param.getParent();
+    if (!Node.isArrowFunction(parent) && !Node.isFunctionExpression(parent))
+        return undefined;
+    const callExpression = parent.getParent();
+    if (!Node.isCallExpression(callExpression))
+        return undefined;
+    const expressionText = callExpression.getExpression().getText();
+    if (!/(^|\.)forwardRef$/.test(expressionText))
+        return undefined;
+    const [, propsTypeNode] = callExpression.getTypeArguments();
+    return propsTypeNode;
+}
+export function resolveFCGenericPropsTypeNode(param) {
+    const funcNode = param.getParent();
+    if (!Node.isArrowFunction(funcNode) && !Node.isFunctionExpression(funcNode))
+        return undefined;
+    const varDecl = funcNode.getParent();
+    if (!Node.isVariableDeclaration(varDecl))
+        return undefined;
+    const typeNode = varDecl.getTypeNode();
+    if (!typeNode || !Node.isTypeReference(typeNode))
+        return undefined;
+    const typeName = typeNode.getTypeName().getText().split('.').pop();
+    if (!typeName || !FC_TYPE_NAMES.has(typeName))
+        return undefined;
+    const typeArgs = typeNode.getTypeArguments();
+    return typeArgs[0];
+}
+export function resolvePropsType(param) {
+    const typeNode = param.getTypeNode();
+    const fcGenericPropsTypeNode = resolveFCGenericPropsTypeNode(param);
+    const fallbackTypeNode = resolveForwardRefGenericPropsTypeNode(param) ?? fcGenericPropsTypeNode;
+    const effectiveTypeNode = typeNode ?? fallbackTypeNode;
+    if (!effectiveTypeNode) {
+        return {
+            type: param.getType(),
+            typeNode: param.getTypeNode() ?? param,
+            hasWrappedChildren: false,
+            suppressProps: false,
+        };
+    }
+    const normalized = normalizePropsTypeNode(effectiveTypeNode);
+    return {
+        type: normalized.typeNode.getType(),
+        typeNode: normalized.typeNode,
+        hasWrappedChildren: normalized.hasWrappedChildren || fcGenericPropsTypeNode !== undefined,
+        suppressProps: normalized.suppressProps,
+    };
+}

package/dist/src/extract/framework-adapters/react/helpers/synthesize-react-structural-slots.d.ts

@@ -0,0 +1,8 @@
+import type { RawComponentDefinition } from '../../../types/component.js';
+import type { FunctionLike } from './resolve-component-function.js';
+import type { Project } from 'ts-morph';
+type ComponentWithFuncNode = RawComponentDefinition & {
+    _funcNode?: FunctionLike;
+};
+export declare function synthesizeReactStructuralSlots(components: ComponentWithFuncNode[], project: Project | undefined): void;
+export {};

package/dist/src/extract/framework-adapters/react/helpers/synthesize-react-structural-slots.js

@@ -0,0 +1,44 @@
+import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from '../../../helpers/evidence/collect-jsx-component-references.js';
+import { buildComponentLookupMaps } from '../../shared/helpers/build-component-lookup-maps.js';
+export function synthesizeReactStructuralSlots(components, project) {
+    const { propsToComponent, componentNames } = buildComponentLookupMaps(components);
+    const structuralByFile = new Map();
+    const structuralNamesForFile = (filePath) => {
+        const cached = structuralByFile.get(filePath);
+        if (cached)
+            return cached;
+        const sourceFile = project?.getSourceFile(filePath);
+        if (!sourceFile)
+            return [];
+        const ctx = { propsToComponent, componentNames };
+        const found = new Set([
+            ...collectTypePredicateComponentReferences(sourceFile, ctx),
+            ...collectRuntimeTypeCheckComponentReferences(sourceFile, componentNames),
+        ]);
+        const names = [...found].sort();
+        structuralByFile.set(filePath, names);
+        return names;
+    };
+    for (const c of components) {
+        const fromFile = structuralNamesForFile(c.source);
+        const fromRender = c._funcNode ? collectRenderedComponentReferences(c._funcNode, componentNames, c.name) : [];
+        const propTypesByName = new Map(c.props.map((p) => [p.name, p.type]));
+        const fromArrayMap = c._funcNode
+            ? collectArrayMapRenderComponentReferences(c._funcNode, componentNames, c.name, propTypesByName)
+            : [];
+        const structural = new Set([...fromFile, ...fromRender, ...fromArrayMap]);
+        if (structural.size === 0)
+            continue;
+        const synthesisedSlot = fromArrayMap.length > 0 && c.slots.length === 0 ? { name: 'children', isDefault: true } : undefined;
+        if (synthesisedSlot)
+            c.slots.push(synthesisedSlot);
+        for (const slot of c.slots) {
+            if (slot.allowedComponents && slot.allowedComponents.length > 0)
+                continue;
+            slot.structuralAllowedComponents = slot === synthesisedSlot ? [...fromArrayMap].sort() : [...structural].sort();
+        }
+    }
+    for (const c of components) {
+        delete c._funcNode;
+    }
+}

package/dist/src/extract/framework-adapters/shared/helpers/build-component-lookup-maps.d.ts

@@ -0,0 +1,5 @@
+import type { RawComponentDefinition } from '../../../types/component.js';
+export declare function buildComponentLookupMaps(components: RawComponentDefinition[]): {
+    propsToComponent: Map<string, string>;
+    componentNames: Set<string>;
+};

package/dist/src/extract/framework-adapters/shared/helpers/build-component-lookup-maps.js

@@ -0,0 +1,10 @@
+export function buildComponentLookupMaps(components) {
+    const propsToComponent = new Map();
+    const componentNames = new Set();
+    for (const c of components) {
+        componentNames.add(c.name);
+        if (c._propsTypeName)
+            propsToComponent.set(c._propsTypeName, c.name);
+    }
+    return { propsToComponent, componentNames };
+}

package/dist/src/extract/framework-adapters/shared/helpers/collect-jsdoc-slot-comments.d.ts

@@ -0,0 +1,2 @@
+import type { ClassDeclaration } from 'ts-morph';
+export declare function collectJsDocSlotComments(classDecl: ClassDeclaration): string[];

package/dist/src/extract/framework-adapters/shared/helpers/collect-jsdoc-slot-comments.js

@@ -0,0 +1,13 @@
+export function collectJsDocSlotComments(classDecl) {
+    const comments = [];
+    for (const jsDoc of classDecl.getJsDocs()) {
+        for (const tag of jsDoc.getTags()) {
+            if (tag.getTagName() !== 'slot')
+                continue;
+            const comment = tag.getCommentText()?.trim();
+            if (comment)
+                comments.push(comment);
+        }
+    }
+    return comments;
+}

package/dist/src/extract/{file-extraction-workers.d.ts → framework-adapters/shared/helpers/file-processing/file-workers.d.ts}

@@ -1,10 +1,9 @@
-import type { Project, SourceFile } from 'ts-morph';
 export type FileExtractionOutcome<T, M = undefined> = {
     item: T | null;
     warnings?: string[];
     metadata?: M;
 };
-type FileExtractionProgress = {
+export type FileExtractionProgress = {
     filesProcessed: number;
     componentsFound: number;
 };
@@ -12,14 +11,3 @@ export declare function runFileExtractionWorkers<T, M = undefined>(filePaths: st
     items: T[];
     warnings: string[];
 }>;
-export declare function createSortedExtractionResult<T extends {
-    name: string;
-}>(components: T[], warnings: string[]): {
-    components: T[];
-    warnings: string[];
-};
-export declare function extractProjectSourceFiles<T>(project: Project, extractFile: (sourceFile: SourceFile, warnings: string[]) => T[]): {
-    items: T[];
-    warnings: string[];
-};
-export {};

package/dist/src/extract/{file-extraction-workers.js → framework-adapters/shared/helpers/file-processing/file-workers.js}

@@ -27,22 +27,3 @@ export async function runFileExtractionWorkers(filePaths, concurrency, extractFi
     await Promise.all(Array.from({ length: Math.min(concurrency, filePaths.length) }, worker));
     return { items, warnings };
 }
-export function createSortedExtractionResult(components, warnings) {
-    return {
-        components: components.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings,
-    };
-}
-export function extractProjectSourceFiles(project, extractFile) {
-    const warnings = [];
-    const items = [];
-    for (const sourceFile of project.getSourceFiles()) {
-        try {
-            items.push(...extractFile(sourceFile, warnings));
-        }
-        catch (error) {
-            warnings.push(`Failed to extract from ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return { items, warnings };
-}

package/dist/src/extract/framework-adapters/shared/helpers/file-processing/project-source-files.d.ts

@@ -0,0 +1,5 @@
+import type { Project, SourceFile } from 'ts-morph';
+export declare function extractProjectSourceFiles<T>(project: Project, extractFile: (sourceFile: SourceFile, warnings: string[]) => T[]): {
+    items: T[];
+    warnings: string[];
+};

package/dist/src/extract/framework-adapters/shared/helpers/file-processing/project-source-files.js

@@ -0,0 +1,13 @@
+export function extractProjectSourceFiles(project, extractFile) {
+    const warnings = [];
+    const items = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        try {
+            items.push(...extractFile(sourceFile, warnings));
+        }
+        catch (error) {
+            warnings.push(`Failed to extract from ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { items, warnings };
+}

package/dist/src/extract/framework-adapters/shared/helpers/file-processing/result-normalizer.d.ts

@@ -0,0 +1,6 @@
+export declare function createSortedExtractionResult<T extends {
+    name: string;
+}>(components: T[], warnings: string[]): {
+    components: T[];
+    warnings: string[];
+};

package/dist/src/extract/framework-adapters/shared/helpers/file-processing/result-normalizer.js

@@ -0,0 +1,6 @@
+export function createSortedExtractionResult(components, warnings) {
+    return {
+        components: components.sort((a, b) => a.name.localeCompare(b.name)),
+        warnings,
+    };
+}

package/dist/src/extract/framework-adapters/shared/helpers/find-tsx-workspace-package.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from 'ts-morph';
+export declare function findWorkspacePackageEntrySourceFile(originSourceFile: SourceFile, moduleSpecifier: string): SourceFile | undefined;

package/dist/src/extract/framework-adapters/shared/helpers/find-tsx-workspace-package.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const packageRootByFilePathCache = new Map();
+const workspacePackageManifestCache = new Map();
+function findNearestPackageRootDir(filePath) {
+    if (packageRootByFilePathCache.has(filePath))
+        return packageRootByFilePathCache.get(filePath) ?? undefined;
+    let currentDir = dirname(filePath);
+    while (true) {
+        if (existsSync(join(currentDir, 'package.json'))) {
+            packageRootByFilePathCache.set(filePath, currentDir);
+            return currentDir;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            packageRootByFilePathCache.set(filePath, null);
+            return undefined;
+        }
+        currentDir = parentDir;
+    }
+}
+function getWorkspacePackageManifestForSourceFile(sourceFile) {
+    const packageRootDir = findNearestPackageRootDir(sourceFile.getFilePath());
+    if (!packageRootDir)
+        return undefined;
+    if (workspacePackageManifestCache.has(packageRootDir))
+        return workspacePackageManifestCache.get(packageRootDir) ?? undefined;
+    const packageJsonPath = join(packageRootDir, 'package.json');
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        const manifest = typeof packageJson.name === 'string' ? { name: packageJson.name, rootDir: packageRootDir } : null;
+        workspacePackageManifestCache.set(packageRootDir, manifest);
+        return manifest ?? undefined;
+    }
+    catch {
+        workspacePackageManifestCache.set(packageRootDir, null);
+        return undefined;
+    }
+}
+export function findWorkspacePackageEntrySourceFile(originSourceFile, moduleSpecifier) {
+    const project = originSourceFile.getProject();
+    const candidateSourceFiles = project.getSourceFiles().filter((sourceFile) => {
+        const manifest = getWorkspacePackageManifestForSourceFile(sourceFile);
+        return manifest?.name === moduleSpecifier;
+    });
+    if (candidateSourceFiles.length === 0)
+        return undefined;
+    const packageRootDir = getWorkspacePackageManifestForSourceFile(candidateSourceFiles[0])?.rootDir;
+    if (!packageRootDir)
+        return undefined;
+    for (const entryPath of [
+        join(packageRootDir, 'src/index.ts'),
+        join(packageRootDir, 'src/index.tsx'),
+        join(packageRootDir, 'index.ts'),
+        join(packageRootDir, 'index.tsx'),
+    ]) {
+        const entrySourceFile = project.getSourceFile(entryPath);
+        if (entrySourceFile)
+            return entrySourceFile;
+    }
+    return candidateSourceFiles.find((sourceFile) => sourceFile.getDirectoryPath() === join(packageRootDir, 'src'));
+}

package/dist/src/extract/{source-line-metadata.d.ts → framework-adapters/shared/helpers/get-node-source-lines.d.ts}

@@ -1,3 +1,3 @@
 import type { Node } from 'ts-morph';
-import type { RawPropDefinition } from '../types.js';
+import type { RawPropDefinition } from '../../../types/component.js';
 export declare function getSourceLineMetadata(declaration: Node | undefined): Pick<RawPropDefinition, 'sourceStartLine' | 'sourceEndLine'>;

package/dist/src/extract/framework-adapters/shared/helpers/resolve-tsx-tsconfig-path.d.ts

@@ -0,0 +1,7 @@
+export declare function matchTsConfigPathPattern(pattern: string, specifier: string): {
+    matched: boolean;
+    wildcard?: string;
+};
+export declare function substituteTsConfigPathTarget(targetPattern: string, wildcard: string | undefined): string;
+export declare function resolveImportSourcePath(basePath: string): string | undefined;
+export declare function resolveRepoLocalAliasImportPath(importingFilePath: string, moduleSpecifier: string): string | undefined;