sicua/dist/analyzers/function/utils/dataValidator.d.ts

A tool for analyzing project structure and dependencies

/**
 * Validation severity levels
 */
declare enum ValidationSeverity {
    ERROR = "error",
    WARNING = "warning",
    INFO = "info"
}
/**
 * Validation issue categories
 */
declare enum ValidationCategory {
    REQUIRED_FIELD = "required_field",
    TYPE_MISMATCH = "type_mismatch",
    FORMAT_INVALID = "format_invalid",
    DATA_QUALITY = "data_quality",
    CONSISTENCY = "consistency",
    COMPLETENESS = "completeness"
}
/**
 * Individual validation issue
 */
interface ValidationIssue {
    category: ValidationCategory;
    severity: ValidationSeverity;
    field: string;
    message: string;
    value: unknown;
    suggestion?: string;
}
/**
 * Validation result for a single function data object
 */
interface FunctionDataValidationResult {
    isValid: boolean;
    issues: ValidationIssue[];
    score: number;
    warnings: number;
    errors: number;
}
/**
 * Batch validation result
 */
interface BatchValidationResult {
    totalFunctions: number;
    validFunctions: number;
    invalidFunctions: number;
    overallScore: number;
    issuesByCategory: Record<ValidationCategory, number>;
    issuesBySeverity: Record<ValidationSeverity, number>;
    functionResults: Map<string, FunctionDataValidationResult>;
}
/**
 * Validation configuration
 */
interface ValidationConfig {
    strictMode: boolean;
    allowEmptyBodies: boolean;
    allowUnknownTypes: boolean;
    maxParameterCount: number;
    maxBodyLength: number;
    requireReturnType: boolean;
    validateTypeNames: boolean;
    checkNameConventions: boolean;
}
/**
 * Function data interface for validation (matches the existing interface)
 */
interface FunctionData {
    componentName: string;
    functionName: string;
    params: string[];
    returnType: string;
    body: string;
    dependencies: string[];
    calledFunctions: string[];
    isAsync: boolean;
}
/**
 * Utility class for validating extracted function data
 */
export declare class DataValidator {
    private config;
    constructor(config?: Partial<ValidationConfig>);
    /**
     * Validates a single function data object
     * @param functionData The function data to validate
     * @returns Validation result
     */
    validateFunctionData(functionData: FunctionData): FunctionDataValidationResult;
    /**
     * Validates a batch of function data objects
     * @param functionDataList Array of function data to validate
     * @returns Batch validation result
     */
    validateBatch(functionDataList: FunctionData[]): BatchValidationResult;
    /**
     * Validates required fields
     */
    private validateRequiredFields;
    /**
     * Validates field types
     */
    private validateFieldTypes;
    /**
     * Validates data formats
     */
    private validateDataFormats;
    /**
     * Validates data quality
     */
    private validateDataQuality;
    /**
     * Validates internal consistency
     */
    private validateConsistency;
    /**
     * Calculates quality score (0-100)
     */
    private calculateQualityScore;
    /**
     * Checks if a string is a valid JavaScript identifier
     */
    private isValidJavaScriptIdentifier;
    /**
     * Checks if a string is a JavaScript reserved word
     */
    private isReservedWord;
    /**
     * Extracts parameter name from parameter string
     */
    private extractParameterName;
    /**
     * Updates validation configuration
     */
    updateConfig(newConfig: Partial<ValidationConfig>): void;
    /**
     * Gets current validation configuration
     */
    getConfig(): ValidationConfig;
}
export {};