@dkoul/auto-testid-core/dist/index.d.ts

Core AST parsing and transformation logic for React and Vue.js attribute generation

export interface Element {
    tag: string;
    attributes: Record<string, string>;
    content?: string;
    children?: Element[];
    position?: SourcePosition;
    framework?: Framework;
}
export interface SourcePosition {
    line: number;
    column: number;
    index: number;
}
export type Framework = 'react' | 'vue' | 'angular' | 'html';
export interface ParseResult {
    elements: Element[];
    errors: ParseError[];
    metadata: ParseMetadata;
}
export interface ParseError {
    message: string;
    position?: SourcePosition;
    severity: 'error' | 'warning' | 'info';
}
export interface ParseMetadata {
    framework: Framework;
    filePath: string;
    sourceLength: number;
    elementsCount: number;
}
export interface TransformResult {
    code: string;
    sourceMap?: string;
    transformations: Transformation[];
    errors: TransformError[];
}
export interface Transformation {
    type: 'add-attribute' | 'modify-attribute' | 'remove-attribute';
    element: Element;
    attribute: string;
    value: string;
    position: SourcePosition;
}
export interface TransformError {
    message: string;
    element?: Element;
    position?: SourcePosition;
    severity: 'error' | 'warning';
}
export interface GenerationContext {
    component?: string;
    filePath: string;
    existingIds: Set<string>;
    namingStrategy: NamingStrategy;
    prefix?: string;
    framework: Framework;
}
export interface NamingStrategy {
    type: 'kebab-case' | 'camelCase' | 'snake_case' | 'custom';
    customTransform?: (input: string) => string;
}
export interface ConfigurationSchema {
    frameworks: Framework[];
    namingStrategy: NamingStrategy;
    prefix?: string;
    attributeName: string;
    exclude: string[];
    includeElementTypes: string[];
    customRules: CustomRule[];
    conflictResolution: 'suffix' | 'prefix' | 'replace';
    maxIdLength: number;
    preserveExisting: boolean;
}
export interface CustomRule {
    selector: string;
    generator: (element: Element, context: GenerationContext) => string;
    priority: number;
}
export interface Parser {
    canParse(filePath: string): boolean;
    parse(content: string, filePath: string): ParseResult;
    transform(content: string, transformations: Transformation[]): TransformResult;
    serialize?(ast: any): string;
}
export interface IDGenerator {
    generate(element: Element, context: GenerationContext): string;
    validateUniqueness(id: string, scope: Set<string>): boolean;
    resolveConflicts(id: string, existingIds: Set<string>): string;
}
export interface Transformer {
    transform(elements: Element[], context: GenerationContext): Transformation[];
    applyTransformations(content: string, transformations: Transformation[]): TransformResult;
}
export interface FileScanner {
    scan(directory: string, options: ScanOptions): Promise<string[]>;
    isSupported(filePath: string): boolean;
    detectFramework(filePath: string, packageJson?: any): Framework;
}
export interface ScanOptions {
    include: string[];
    exclude: string[];
    frameworks: Framework[];
    recursive: boolean;
    maxFiles?: number;
}
export interface AutoTestIDCore {
    processFile(filePath: string, options?: ProcessOptions): Promise<ProcessResult>;
    processFiles(filePaths: string[], options?: ProcessOptions): Promise<ProcessResult[]>;
    scanDirectory(directory: string, options?: ScanOptions): Promise<string[]>;
    validateConfiguration(config: Partial<ConfigurationSchema>): ValidationResult;
}
export interface ProcessOptions {
    dryRun?: boolean;
    backup?: boolean;
    config?: Partial<ConfigurationSchema>;
    onProgress?: (progress: ProcessProgress) => void;
}
export interface ProcessResult {
    filePath: string;
    success: boolean;
    transformations: Transformation[];
    errors: TransformError[];
    metrics: ProcessMetrics;
    diff?: string;
}
export interface ProcessProgress {
    total: number;
    completed: number;
    current: string;
    stage: 'scanning' | 'parsing' | 'generating' | 'transforming' | 'writing';
}
export interface ProcessMetrics {
    elementsFound: number;
    elementsTransformed: number;
    idGenerated: number;
    conflictsResolved: number;
    processingTime: number;
}
export interface ValidationResult {
    valid: boolean;
    errors: ValidationError[];
    warnings: ValidationError[];
}
export interface ValidationError {
    message: string;
    path: string;
    value?: any;
}
export * from './parsers';
export * from './generators';
export * from './transformers';
export * from './utils';
export declare function createAutoTestID(config?: Partial<ConfigurationSchema>): AutoTestIDCore;
export declare const DEFAULT_CONFIG: ConfigurationSchema;
//# sourceMappingURL=index.d.ts.map