@contentful/experience-design-system-cli 2.12.4-dev-build-9c819d8.0 → 2.13.1-dev-build-847dead.0

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

@@ -1,8 +0,0 @@
-import { Node, type Type } from 'ts-morph';
-export declare function extractAllowedValues(type: Type): string[] | 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/analyze/extract/tsx-shared.js

@@ -1,263 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { Node } from 'ts-morph';
-import ts from 'typescript';
-const packageRootByFilePathCache = new Map();
-const workspacePackageManifestCache = new Map();
-const nearestTsConfigPathCache = new Map();
-const tsConfigPathsCache = new Map();
-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;
-}
-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;
-    }
-}

package/dist/src/analyze/extract/validate.d.ts

@@ -1,16 +0,0 @@
-import type { RawComponentDefinition, ExtractionValidationIssue } from '../../types.js';
-export type { ExtractionValidationIssue } from '../../types.js';
-export declare function validateExtractedComponents(components: RawComponentDefinition[]): RawComponentDefinition[];
-export declare function shouldExcludeDueToValidation(component: RawComponentDefinition): boolean;
-/**
- * Format a stderr-ready warning describing components auto-rejected by the
- * extraction gate. Used by `analyze select --select-all --exclude-invalid`
- * and `analyze select-agent --exclude-invalid` so both opt-in paths emit a
- * consistent message — non-interactive callers (CI, orchestrator, scripted
- * pipeline) need to see WHICH components were excluded and WHY, not just
- * the bare counts.
- */
-export declare function formatExclusionWarning(rejected: Array<{
-    name: string;
-    validationIssues?: ExtractionValidationIssue[];
-}>): string;

package/dist/src/analyze/extract/validate.js

@@ -1,94 +0,0 @@
-export function validateExtractedComponents(components) {
-    const nameCounts = new Map();
-    for (const component of components) {
-        const key = component.name.trim();
-        nameCounts.set(key, (nameCounts.get(key) ?? 0) + 1);
-    }
-    return components.map((component) => {
-        const issues = [];
-        if (!component.name.trim()) {
-            issues.push({
-                severity: 'error',
-                code: 'EMPTY_COMPONENT_NAME',
-                message: 'Component name must not be empty',
-            });
-        }
-        for (let i = 0; i < component.props.length; i++) {
-            if (!component.props[i].name.trim()) {
-                issues.push({
-                    severity: 'error',
-                    code: 'EMPTY_PROP_NAME',
-                    message: `Prop at index ${i} has an empty name`,
-                    field: `props[${i}].name`,
-                });
-            }
-        }
-        for (let i = 0; i < component.slots.length; i++) {
-            if (!component.slots[i].name.trim()) {
-                // Warning, not error: SP-2's renameEmptySlots auto-recovers empty slot
-                // names to children/slot_<n> before the LLM prompt, so the component
-                // can still be generated. Asymmetric with EMPTY_PROP_NAME (still error)
-                // because that path silently drops empty-named props in
-                // loadCDFComponents — real data loss — instead of recovering them.
-                issues.push({
-                    severity: 'warning',
-                    code: 'EMPTY_SLOT_NAME',
-                    message: `Slot at index ${i} has an empty name`,
-                    field: `slots[${i}].name`,
-                });
-            }
-        }
-        const propNames = new Set(component.props.map((p) => p.name.trim()).filter(Boolean));
-        for (let i = 0; i < component.slots.length; i++) {
-            const slotName = component.slots[i].name.trim();
-            if (slotName && propNames.has(slotName)) {
-                issues.push({
-                    severity: 'error',
-                    code: 'PROP_SLOT_NAME_COLLISION',
-                    message: `"${slotName}" is used as both a prop name and a slot name`,
-                    field: `slots[${i}].name`,
-                });
-            }
-        }
-        const nameKey = component.name.trim();
-        if (nameKey && (nameCounts.get(nameKey) ?? 0) > 1) {
-            issues.push({
-                severity: 'error',
-                code: 'DUPLICATE_COMPONENT_NAME',
-                message: `Component name "${component.name}" appears more than once in the extracted set`,
-            });
-        }
-        if (component.props.length === 0 && component.slots.length === 0) {
-            issues.push({
-                severity: 'warning',
-                code: 'EMPTY_COMPONENT',
-                message: 'Component has no props or slots and will be filtered out during generation',
-            });
-        }
-        return { ...component, validationIssues: issues };
-    });
-}
-export function shouldExcludeDueToValidation(component) {
-    return (component.validationIssues ?? []).some((i) => i.severity === 'error');
-}
-/**
- * Format a stderr-ready warning describing components auto-rejected by the
- * extraction gate. Used by `analyze select --select-all --exclude-invalid`
- * and `analyze select-agent --exclude-invalid` so both opt-in paths emit a
- * consistent message — non-interactive callers (CI, orchestrator, scripted
- * pipeline) need to see WHICH components were excluded and WHY, not just
- * the bare counts.
- */
-export function formatExclusionWarning(rejected) {
-    if (rejected.length === 0)
-        return '';
-    const lines = [`Warning: ${rejected.length} component(s) excluded due to validation errors:`];
-    for (const comp of rejected) {
-        const codes = (comp.validationIssues ?? [])
-            .filter((i) => i.severity === 'error')
-            .map((i) => i.code)
-            .join(', ');
-        lines.push(`  ✗  ${comp.name}  ${codes}`);
-    }
-    return lines.join('\n') + '\n';
-}

package/dist/src/analyze/extract/vue-tsx.d.ts

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