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

package/dist/src/extract/tsx-shared.d.ts

@@ -1,37 +0,0 @@
-import { Node, Project, type SourceFile, type Type } from 'ts-morph';
-import type { ExtractionExclusion } from '../types.js';
-export declare function getTsxExtractionContext(filePaths: string[], componentFilePattern: RegExp): {
-    componentFiles: string[];
-    project: Project;
-} | undefined;
-export declare function extractTsxComponents<T>(filePaths: string[], componentFilePattern: RegExp, extract: (sourceFile: SourceFile, exclusions: ExtractionExclusion[]) => T[]): {
-    components: T[];
-    warnings: string[];
-    exclusions: ExtractionExclusion[];
-    project?: Project;
-};
-export declare function resolveDefaultExportName(declarations: Node[], exported: {
-    has(name: string): boolean;
-}, allowVariableDeclaration?: boolean): string | undefined;
-export declare function getRenderableExports(sourceFile: SourceFile, exclusions: ExtractionExclusion[], options: {
-    allowVariableDeclaration?: boolean;
-    hookReason: string;
-}): Array<{
-    name: string;
-    declarations: Node[];
-}>;
-export declare function kebabToPascal(input: string): string;
-export declare function extractAllowedValues(type: Type): string[] | undefined;
-/**
- * Custom elements include a hyphen. Lowercase, unqualified tags are therefore
- * the conservative syntactic form for intrinsic JSX elements.
- */
-export declare function isIntrinsicJsxElement(tagName: string): boolean;
-/** The tag name of the JSX element that owns an attribute or spread. */
-export declare function getJsxTagNameNode(node: Node): Node | undefined;
-export declare function getNodeDefinitions(node: Node): {
-    getDeclarationNode(): Node | undefined;
-}[];
-export declare function getTypeTargetDeclarations(targetNode: Node, allowWorkspaceImportFallback?: boolean): Node[];
-export declare function getValueTargetDeclarations(targetNode: Node): Node[];
-export declare function getTypeReferenceName(typeNode: Node): string | undefined;

package/dist/src/extract/tsx-shared.js

@@ -1,368 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { Node, Project, SyntaxKind } from 'ts-morph';
-import ts from 'typescript';
-const packageRootByFilePathCache = new Map();
-const workspacePackageManifestCache = new Map();
-const nearestTsConfigPathCache = new Map();
-const tsConfigPathsCache = new Map();
-function createTsxProject(filePaths) {
-    const project = new Project({
-        compilerOptions: {
-            jsx: 1,
-            target: 99,
-            module: 99,
-            moduleResolution: 100,
-            skipLibCheck: true,
-            allowJs: true,
-        },
-        skipAddingFilesFromTsConfig: true,
-    });
-    for (const filePath of filePaths) {
-        project.addSourceFileAtPath(filePath);
-    }
-    return project;
-}
-function getTsxProjectFiles(filePaths) {
-    return filePaths.filter((filePath) => /\.[jt]sx?$/.test(filePath) && !filePath.endsWith('.d.ts'));
-}
-export function getTsxExtractionContext(filePaths, componentFilePattern) {
-    const componentFiles = filePaths.filter((filePath) => componentFilePattern.test(filePath));
-    if (componentFiles.length === 0)
-        return undefined;
-    return {
-        componentFiles,
-        project: createTsxProject(getTsxProjectFiles(filePaths)),
-    };
-}
-export function extractTsxComponents(filePaths, componentFilePattern, extract) {
-    const extractionContext = getTsxExtractionContext(filePaths, componentFilePattern);
-    if (!extractionContext) {
-        return { components: [], warnings: [], exclusions: [] };
-    }
-    const { componentFiles, project } = extractionContext;
-    const components = [];
-    const warnings = [];
-    const exclusions = [];
-    for (const filePath of componentFiles) {
-        try {
-            const sourceFile = project.getSourceFile(filePath);
-            if (!sourceFile)
-                continue;
-            components.push(...extract(sourceFile, exclusions));
-        }
-        catch (e) {
-            warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    return { components, warnings, exclusions, project };
-}
-export function resolveDefaultExportName(declarations, exported, allowVariableDeclaration = false) {
-    const declaration = declarations[0];
-    const name = Node.isFunctionDeclaration(declaration)
-        ? declaration.getName()
-        : allowVariableDeclaration && Node.isVariableDeclaration(declaration)
-            ? declaration.getName()
-            : undefined;
-    if (!name || !/^[A-Z]/.test(name) || exported.has(name))
-        return undefined;
-    return name;
-}
-export function getRenderableExports(sourceFile, exclusions, options) {
-    const renderable = [];
-    const exported = sourceFile.getExportedDeclarations();
-    for (const [exportKey, declarations] of exported) {
-        const name = exportKey === 'default'
-            ? resolveDefaultExportName(declarations, exported, options.allowVariableDeclaration)
-            : exportKey;
-        if (!name || !/^[A-Z]/.test(name))
-            continue;
-        if (name.startsWith('use')) {
-            exclusions.push({
-                itemType: 'component',
-                name,
-                source: sourceFile.getFilePath(),
-                reason: options.hookReason,
-                stage: 'component-filter',
-            });
-            continue;
-        }
-        renderable.push({ name, declarations });
-    }
-    return renderable;
-}
-export function kebabToPascal(input) {
-    return input
-        .split('-')
-        .filter(Boolean)
-        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-        .join('');
-}
-export function extractAllowedValues(type) {
-    if (!type.isUnion())
-        return undefined;
-    const literals = type
-        .getUnionTypes()
-        .filter((t) => t.isStringLiteral())
-        .map((t) => t.getLiteralValueOrThrow());
-    return literals.length >= 2 ? literals.sort() : undefined;
-}
-/**
- * Custom elements include a hyphen. Lowercase, unqualified tags are therefore
- * the conservative syntactic form for intrinsic JSX elements.
- */
-export function isIntrinsicJsxElement(tagName) {
-    return /^[a-z][A-Za-z0-9]*$/.test(tagName);
-}
-/** The tag name of the JSX element that owns an attribute or spread. */
-export function getJsxTagNameNode(node) {
-    const openingElement = node.getFirstAncestorByKind(SyntaxKind.JsxOpeningElement);
-    const selfClosingElement = node.getFirstAncestorByKind(SyntaxKind.JsxSelfClosingElement);
-    return openingElement?.getTagNameNode() ?? selfClosingElement?.getTagNameNode();
-}
-export function getNodeDefinitions(node) {
-    const anyNode = node;
-    return anyNode.getDefinitions?.() ?? [];
-}
-export function getTypeTargetDeclarations(targetNode, allowWorkspaceImportFallback = false) {
-    return getNodeDefinitions(targetNode).flatMap((definition) => {
-        const declaration = definition.getDeclarationNode();
-        if (!declaration)
-            return [];
-        if (!allowWorkspaceImportFallback || !Node.isImportSpecifier(declaration)) {
-            return [declaration];
-        }
-        const resolvedDeclarations = resolveWorkspaceImportSpecifierDeclarations(declaration, targetNode);
-        return resolvedDeclarations.length > 0 ? resolvedDeclarations : [declaration];
-    });
-}
-export function getValueTargetDeclarations(targetNode) {
-    return getNodeDefinitions(targetNode).flatMap((definition) => {
-        const declaration = definition.getDeclarationNode();
-        if (!declaration)
-            return [];
-        if (!Node.isImportSpecifier(declaration)) {
-            return [declaration];
-        }
-        const resolvedDeclarations = resolveWorkspaceImportSpecifierDeclarations(declaration, targetNode);
-        return resolvedDeclarations.length > 0 ? resolvedDeclarations : [declaration];
-    });
-}
-export function getTypeReferenceName(typeNode) {
-    if (Node.isTypeReference(typeNode)) {
-        return typeNode.getTypeName().getText().split('.').pop();
-    }
-    if (Node.isExpressionWithTypeArguments(typeNode)) {
-        return typeNode.getExpression().getText().split('.').pop();
-    }
-    return undefined;
-}
-function resolveWorkspaceImportSpecifierDeclarations(importSpecifier, referenceNode) {
-    if (!Node.isImportSpecifier(importSpecifier))
-        return [];
-    const importDeclaration = importSpecifier.getImportDeclaration();
-    const moduleSpecifierSourceFile = importDeclaration.getModuleSpecifierSourceFile();
-    if (moduleSpecifierSourceFile) {
-        return getExportedDeclarationsForImportSpecifier(importSpecifier, moduleSpecifierSourceFile);
-    }
-    const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
-    if (!isBareModuleSpecifier(moduleSpecifier))
-        return [];
-    const workspaceEntrySourceFile = findWorkspacePackageEntrySourceFile(referenceNode.getSourceFile(), moduleSpecifier);
-    if (workspaceEntrySourceFile) {
-        return getExportedDeclarationsForImportSpecifier(importSpecifier, workspaceEntrySourceFile);
-    }
-    const aliasedSourceFile = findRepoLocalAliasSourceFile(referenceNode.getSourceFile(), moduleSpecifier);
-    if (!aliasedSourceFile)
-        return [];
-    return getExportedDeclarationsForImportSpecifier(importSpecifier, aliasedSourceFile);
-}
-function getExportedDeclarationsForImportSpecifier(importSpecifier, sourceFile) {
-    if (!Node.isImportSpecifier(importSpecifier))
-        return [];
-    const exportedName = importSpecifier.getNameNode().getText();
-    return sourceFile.getExportedDeclarations().get(exportedName) ?? [];
-}
-function isBareModuleSpecifier(moduleSpecifier) {
-    return !moduleSpecifier.startsWith('.') && !moduleSpecifier.startsWith('/');
-}
-function findRepoLocalAliasSourceFile(originSourceFile, moduleSpecifier) {
-    const resolvedPath = resolveRepoLocalAliasImportPath(originSourceFile.getFilePath(), moduleSpecifier);
-    if (!resolvedPath)
-        return undefined;
-    const project = originSourceFile.getProject();
-    return findProjectSourceFileByImportPath(project, resolvedPath);
-}
-function resolveRepoLocalAliasImportPath(importingFilePath, moduleSpecifier) {
-    const nearestTsConfigPath = findNearestTsConfigPath(importingFilePath);
-    if (!nearestTsConfigPath)
-        return undefined;
-    const tsConfigPaths = getTsConfigPaths(nearestTsConfigPath);
-    if (!tsConfigPaths)
-        return undefined;
-    for (const [pattern, targets] of Object.entries(tsConfigPaths.paths)) {
-        const match = matchTsConfigPathPattern(pattern, moduleSpecifier);
-        if (!match.matched)
-            continue;
-        for (const targetPattern of targets) {
-            const substitutedTarget = substituteTsConfigPathTarget(targetPattern, match.wildcard);
-            const resolvedPath = resolve(tsConfigPaths.baseUrl, substitutedTarget);
-            const sourceFilePath = resolveImportSourcePath(resolvedPath);
-            if (sourceFilePath)
-                return sourceFilePath;
-        }
-    }
-    return undefined;
-}
-function findNearestTsConfigPath(filePath) {
-    if (nearestTsConfigPathCache.has(filePath)) {
-        return nearestTsConfigPathCache.get(filePath) ?? undefined;
-    }
-    let currentDir = dirname(filePath);
-    while (true) {
-        for (const candidateName of ['tsconfig.json', 'jsconfig.json']) {
-            const candidatePath = join(currentDir, candidateName);
-            if (existsSync(candidatePath)) {
-                nearestTsConfigPathCache.set(filePath, candidatePath);
-                return candidatePath;
-            }
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            nearestTsConfigPathCache.set(filePath, null);
-            return undefined;
-        }
-        currentDir = parentDir;
-    }
-}
-function getTsConfigPaths(tsConfigPath) {
-    if (tsConfigPathsCache.has(tsConfigPath)) {
-        return tsConfigPathsCache.get(tsConfigPath) ?? undefined;
-    }
-    const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-    if (configFile.error || !configFile.config) {
-        tsConfigPathsCache.set(tsConfigPath, null);
-        return undefined;
-    }
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(tsConfigPath));
-    const paths = parsedConfig.options.paths;
-    if (!paths || Object.keys(paths).length === 0) {
-        tsConfigPathsCache.set(tsConfigPath, null);
-        return undefined;
-    }
-    const baseUrl = parsedConfig.options.baseUrl ?? dirname(tsConfigPath);
-    const result = { baseUrl, paths };
-    tsConfigPathsCache.set(tsConfigPath, result);
-    return result;
-}
-function matchTsConfigPathPattern(pattern, specifier) {
-    if (!pattern.includes('*')) {
-        return { matched: pattern === specifier };
-    }
-    const [prefix, suffix] = pattern.split('*');
-    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) {
-        return { matched: false };
-    }
-    return {
-        matched: true,
-        wildcard: specifier.slice(prefix.length, specifier.length - suffix.length),
-    };
-}
-function substituteTsConfigPathTarget(targetPattern, wildcard) {
-    return wildcard === undefined ? targetPattern : targetPattern.replace('*', wildcard);
-}
-function resolveImportSourcePath(basePath) {
-    const candidates = [
-        basePath,
-        `${basePath}.ts`,
-        `${basePath}.tsx`,
-        `${basePath}.js`,
-        `${basePath}.jsx`,
-        join(basePath, 'index.ts'),
-        join(basePath, 'index.tsx'),
-        join(basePath, 'index.js'),
-        join(basePath, 'index.jsx'),
-    ];
-    return candidates.find((candidatePath) => existsSync(candidatePath));
-}
-function findProjectSourceFileByImportPath(project, resolvedPath) {
-    const candidatePaths = [
-        resolvedPath,
-        `${resolvedPath}.ts`,
-        `${resolvedPath}.tsx`,
-        `${resolvedPath}.js`,
-        `${resolvedPath}.jsx`,
-        join(resolvedPath, 'index.ts'),
-        join(resolvedPath, 'index.tsx'),
-        join(resolvedPath, 'index.js'),
-        join(resolvedPath, 'index.jsx'),
-    ];
-    for (const candidatePath of candidatePaths) {
-        const sourceFile = project.getSourceFile(candidatePath);
-        if (sourceFile)
-            return sourceFile;
-    }
-    return undefined;
-}
-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;
-    const preferredEntryPaths = [
-        join(packageRootDir, 'src/index.ts'),
-        join(packageRootDir, 'src/index.tsx'),
-        join(packageRootDir, 'index.ts'),
-        join(packageRootDir, 'index.tsx'),
-    ];
-    for (const entryPath of preferredEntryPaths) {
-        const entrySourceFile = project.getSourceFile(entryPath);
-        if (entrySourceFile) {
-            return entrySourceFile;
-        }
-    }
-    return candidateSourceFiles.find((sourceFile) => sourceFile.getDirectoryPath() === join(packageRootDir, 'src'));
-}
-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;
-    }
-}
-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;
-    }
-}