@casoon/auditmysite
Version:
Professional website analysis suite with robust accessibility testing, Core Web Vitals performance monitoring, SEO analysis, and content optimization insights. Features isolated browser contexts, retry mechanisms, and comprehensive API endpoints for profe
517 lines • 22 kB
JavaScript
;
/**
* 🔄 AUDIT DATA ADAPTER - LEGACY TO STRICT CONVERSION
*
* Diese Adapter-Schicht transformiert die bestehenden flexiblen/lockeren
* Audit-Datenstrukturen in strikt validierte, vollständige Strukturen.
* Sie fungiert als Bridge zwischen dem bestehenden System und dem neuen
* strikten Validierungs-System.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuditDataAdapter = void 0;
exports.convertAndValidateAuditData = convertAndValidateAuditData;
exports.safeConvertAuditData = safeConvertAuditData;
const strict_audit_validators_1 = require("../validators/strict-audit-validators");
const strict_audit_types_1 = require("../types/strict-audit-types");
// ============================================================================
// TYPE MAPPINGS - LEGACY TO STRICT
// ============================================================================
/**
* Adapter: Konvertiert Legacy AuditResult zu StrictAuditData
*/
class AuditDataAdapter {
/**
* Hauptkonvertierung: Legacy AuditResult → StrictAuditData
*/
static convertToStrict(legacyResult) {
try {
console.log('🔄 Converting legacy audit data to strict format...');
// First, transform legacy structure to intermediate format
const intermediateData = this.transformLegacyStructure(legacyResult);
// Then apply strict validation and create strict object
const strictData = (0, strict_audit_validators_1.createStrictAuditData)(intermediateData);
console.log('✅ Successfully converted to strict audit data');
console.log(` Pages: ${strictData.pages.length}`);
console.log(` Total Errors: ${strictData.summary.totalErrors}`);
console.log(` Total Warnings: ${strictData.summary.totalWarnings}`);
return strictData;
}
catch (error) {
if (error instanceof strict_audit_types_1.IncompleteAuditDataError || error instanceof strict_audit_types_1.MissingAnalysisError) {
console.error('❌ Strict validation failed:', error.message);
throw error;
}
throw new strict_audit_types_1.IncompleteAuditDataError(`Audit data conversion failed: ${error instanceof Error ? error.message : 'Unknown error'}`, ['conversion_error']);
}
}
/**
* Legacy-Struktur zu Intermediate-Format transformieren
*/
static transformLegacyStructure(legacyResult) {
// Transform metadata
const metadata = {
version: legacyResult.metadata?.version || '1.0.0',
timestamp: legacyResult.metadata?.timestamp || new Date().toISOString(),
sitemapUrl: legacyResult.metadata?.sitemapUrl || '',
toolVersion: legacyResult.metadata?.toolVersion || '2.0.0-alpha.2',
duration: typeof legacyResult.metadata?.duration === 'number' ?
legacyResult.metadata.duration : 0,
maxPages: typeof legacyResult.metadata?.maxPages === 'number' ?
legacyResult.metadata.maxPages : (legacyResult.pages?.length || 0),
timeout: typeof legacyResult.metadata?.timeout === 'number' ?
legacyResult.metadata.timeout : 30000,
standard: typeof legacyResult.metadata?.standard === 'string' ?
legacyResult.metadata.standard : 'WCAG2AA',
features: Array.isArray(legacyResult.metadata?.features) ?
legacyResult.metadata.features :
['accessibility', 'performance', 'seo', 'contentWeight', 'mobileFriendliness']
};
// Transform summary with defensive fallbacks
const summary = {
totalPages: legacyResult.summary?.totalPages || (legacyResult.pages?.length || 0),
testedPages: legacyResult.summary?.testedPages || (legacyResult.pages?.length || 0),
passedPages: legacyResult.summary?.passedPages || 0,
failedPages: legacyResult.summary?.failedPages || 0,
crashedPages: legacyResult.summary?.crashedPages || 0,
redirectPages: legacyResult.summary?.redirectPages || 0,
totalErrors: legacyResult.summary?.totalErrors || 0,
totalWarnings: legacyResult.summary?.totalWarnings || 0,
averageScore: legacyResult.summary?.averageScore || 0,
overallGrade: legacyResult.summary?.overallGrade || 'F'
};
// Transform pages with comprehensive data enhancement
const pages = (legacyResult.pages || []).map((page) => this.transformLegacyPage(page));
// Transform system performance
const systemPerformance = {
testCompletionTimeSeconds: Math.round((metadata.duration || 0) / 1000),
averageTimePerPageMs: Math.round((metadata.duration || 0) / Math.max(pages.length, 1)),
throughputPagesPerMinute: Math.round(pages.length / Math.max((metadata.duration || 1) / 1000 / 60, 1)),
memoryUsageMB: legacyResult.systemPerformance?.memoryUsageMB || 0,
efficiency: pages.length > 0 ? 100.0 : 0.0
};
return {
metadata,
summary,
pages,
systemPerformance
};
}
/**
* Legacy PageResult zu Strict-kompatiblem Format transformieren
*/
static transformLegacyPage(legacyPage) {
return {
url: legacyPage.url || '',
title: legacyPage.title || 'Untitled Page',
status: this.normalizePageStatus(legacyPage.status),
duration: typeof legacyPage.duration === 'number' ? legacyPage.duration : 0,
testedAt: legacyPage.testedAt || new Date().toISOString(),
// Transform each analysis type with comprehensive fallbacks
accessibility: this.transformAccessibilityResult(legacyPage.accessibility, legacyPage.url || 'unknown-url'),
performance: this.transformPerformanceResult(legacyPage.performance, legacyPage.url || 'unknown-url'),
seo: this.transformSEOResult(legacyPage.seo, legacyPage.url || 'unknown-url'),
contentWeight: this.transformContentWeightResult(legacyPage.contentWeight, legacyPage.url || 'unknown-url'),
mobileFriendliness: this.transformMobileFriendlinessResult(legacyPage.mobileFriendliness, legacyPage.url || 'unknown-url')
};
}
/**
* Normalisiert Page Status zu erlaubten Werten
*/
static normalizePageStatus(status) {
if (status === 'passed' || status === 'failed' || status === 'crashed') {
return status;
}
// Try to infer from status content
if (typeof status === 'string') {
const lowerStatus = status.toLowerCase();
if (lowerStatus.includes('pass'))
return 'passed';
if (lowerStatus.includes('crash') || lowerStatus.includes('error'))
return 'crashed';
if (lowerStatus.includes('fail'))
return 'failed';
}
return 'crashed'; // Conservative fallback
}
/**
* Legacy Accessibility zu Strict-Format transformieren
*/
static transformAccessibilityResult(legacy, pageUrl) {
if (!legacy) {
console.warn(`⚠️ Missing accessibility data for ${pageUrl}, creating empty structure`);
return {
score: 0,
errors: [],
warnings: [],
notices: []
};
}
return {
score: typeof legacy.score === 'number' ? legacy.score : 0,
errors: this.transformAccessibilityIssues(legacy.errors, 'error'),
warnings: this.transformAccessibilityIssues(legacy.warnings, 'warning'),
notices: this.transformAccessibilityIssues(legacy.notices || [], 'notice')
};
}
/**
* Transformiert Accessibility-Issues zu Strict-Format
*/
static transformAccessibilityIssues(issues, type) {
if (!Array.isArray(issues)) {
return [];
}
return issues.map((issue) => {
// Handle both object and string formats
if (typeof issue === 'string') {
return {
code: 'legacy-string-issue',
message: issue,
type: type,
selector: null,
context: null,
impact: null,
help: null,
helpUrl: null
};
}
return {
code: issue?.code || 'unknown-rule',
message: issue?.message || issue?.description || 'No description available',
type: issue?.type || type,
selector: issue?.selector || null,
context: issue?.context || null,
impact: issue?.impact && ['minor', 'moderate', 'serious', 'critical'].includes(issue.impact) ?
issue.impact : null,
help: issue?.help || null,
helpUrl: issue?.helpUrl || null
};
});
}
/**
* Legacy Performance zu Strict-Format transformieren
*/
static transformPerformanceResult(legacy, pageUrl) {
if (!legacy) {
console.warn(`⚠️ Missing performance data for ${pageUrl}, creating minimal structure`);
return {
score: 0,
grade: 'F',
coreWebVitals: this.createDefaultCoreWebVitals(),
issues: [`Performance analysis failed for ${pageUrl}`]
};
}
return {
score: typeof legacy.score === 'number' ? legacy.score : 0,
grade: legacy.grade || this.scoreToGrade(legacy.score || 0),
coreWebVitals: this.transformCoreWebVitals(legacy.coreWebVitals),
issues: Array.isArray(legacy.issues) ?
legacy.issues.filter((i) => typeof i === 'string') : []
};
}
/**
* Core Web Vitals transformieren mit Fallback-Werten
*/
static transformCoreWebVitals(coreWebVitals) {
return {
largestContentfulPaint: coreWebVitals?.largestContentfulPaint || 0,
firstContentfulPaint: coreWebVitals?.firstContentfulPaint || 0,
cumulativeLayoutShift: coreWebVitals?.cumulativeLayoutShift || 0,
timeToFirstByte: coreWebVitals?.timeToFirstByte || 0,
domContentLoaded: coreWebVitals?.domContentLoaded || 0,
loadComplete: coreWebVitals?.loadComplete || 0,
firstPaint: coreWebVitals?.firstPaint || 0
};
}
/**
* Standard Core Web Vitals für fehlende Performance-Daten
*/
static createDefaultCoreWebVitals() {
return {
largestContentfulPaint: 0,
firstContentfulPaint: 0,
cumulativeLayoutShift: 0,
timeToFirstByte: 0,
domContentLoaded: 0,
loadComplete: 0,
firstPaint: 0
};
}
/**
* Legacy SEO zu Strict-Format transformieren
*/
static transformSEOResult(legacy, pageUrl) {
if (!legacy) {
console.warn(`⚠️ Missing SEO data for ${pageUrl}, creating minimal structure`);
return {
score: 0,
grade: 'F',
metaTags: this.createDefaultSEOData(),
issues: [`SEO analysis failed for ${pageUrl}`],
recommendations: []
};
}
return {
score: typeof legacy.score === 'number' ? legacy.score : 0,
grade: legacy.grade || this.scoreToGrade(legacy.score || 0),
metaTags: this.transformSEOMetaTags(legacy.metaTags || legacy),
issues: Array.isArray(legacy.issues) ?
legacy.issues.filter((i) => typeof i === 'string') : [],
recommendations: Array.isArray(legacy.recommendations) ?
legacy.recommendations.filter((r) => typeof r === 'string') : []
};
}
/**
* SEO Meta-Tags transformieren
*/
static transformSEOMetaTags(metaTags) {
return {
title: metaTags?.title || '',
titleLength: metaTags?.titleLength || (metaTags?.title?.length || 0),
description: metaTags?.description || '',
descriptionLength: metaTags?.descriptionLength || (metaTags?.description?.length || 0),
keywords: metaTags?.keywords || '',
h1Count: metaTags?.h1 || metaTags?.headings?.h1 || 0,
h2Count: metaTags?.h2 || metaTags?.headings?.h2 || 0,
h3Count: metaTags?.h3 || metaTags?.headings?.h3 || 0,
totalImages: metaTags?.total || metaTags?.images?.total || 0,
imagesWithoutAlt: metaTags?.withoutAlt || metaTags?.images?.withoutAlt || 0,
imagesWithEmptyAlt: metaTags?.withEmptyAlt || metaTags?.images?.withEmptyAlt || 0
};
}
/**
* Standard SEO-Daten für fehlende SEO-Analyse
*/
static createDefaultSEOData() {
return {
title: '',
titleLength: 0,
description: '',
descriptionLength: 0,
keywords: '',
h1Count: 0,
h2Count: 0,
h3Count: 0,
totalImages: 0,
imagesWithoutAlt: 0,
imagesWithEmptyAlt: 0
};
}
/**
* Legacy Content Weight zu Strict-Format transformieren
*/
static transformContentWeightResult(legacy, pageUrl) {
if (!legacy) {
console.warn(`⚠️ Missing content weight data for ${pageUrl}, creating minimal structure`);
return {
score: 0,
grade: 'F',
resources: this.createDefaultContentWeightData(),
optimizations: [`Content weight analysis failed for ${pageUrl}`]
};
}
return {
score: typeof legacy.score === 'number' ? legacy.score : 0,
grade: legacy.grade || this.scoreToGrade(legacy.score || 0),
resources: this.transformContentWeightResources(legacy.resources || legacy),
optimizations: Array.isArray(legacy.optimizations) ?
legacy.optimizations.filter((o) => typeof o === 'string') : []
};
}
/**
* Content Weight Resources transformieren
*/
static transformContentWeightResources(resources) {
return {
totalSize: resources?.totalSize || resources?.total || 0,
html: {
size: resources?.html?.size || 0,
files: resources?.html?.files || 1
},
css: {
size: resources?.css?.size || 0,
files: resources?.css?.files || 0
},
javascript: {
size: resources?.javascript?.size || 0,
files: resources?.javascript?.files || 0
},
images: {
size: resources?.images?.size || 0,
files: resources?.images?.files || 0
},
other: {
size: resources?.other?.size || 0,
files: resources?.other?.files || 0
}
};
}
/**
* Standard Content Weight Daten für fehlende Analyse
*/
static createDefaultContentWeightData() {
return {
totalSize: 0,
html: { size: 0, files: 1 },
css: { size: 0, files: 0 },
javascript: { size: 0, files: 0 },
images: { size: 0, files: 0 },
other: { size: 0, files: 0 }
};
}
/**
* Legacy Mobile Friendliness zu Strict-Format transformieren
*/
static transformMobileFriendlinessResult(legacy, pageUrl) {
if (!legacy) {
console.warn(`⚠️ Missing mobile friendliness data for ${pageUrl}, creating minimal structure`);
return {
overallScore: 0,
grade: 'F',
recommendations: [{
category: 'Performance',
priority: 'high',
issue: 'Mobile friendliness analysis failed',
recommendation: 'Retry mobile analysis',
impact: `Analysis could not complete for ${pageUrl}`
}]
};
}
return {
overallScore: typeof legacy.overallScore === 'number' ? legacy.overallScore : 0,
grade: legacy.grade || this.scoreToGrade(legacy.overallScore || 0),
recommendations: this.transformMobileRecommendations(legacy.recommendations || [])
};
}
/**
* Mobile Recommendations transformieren
*/
static transformMobileRecommendations(recommendations) {
if (!Array.isArray(recommendations)) {
return [];
}
const validCategories = ['Touch Targets', 'Performance', 'Media', 'Forms', 'Navigation', 'Content'];
const validPriorities = ['low', 'medium', 'high', 'critical'];
return recommendations.map((rec) => ({
category: validCategories.includes(rec?.category) ? rec.category : 'Content',
priority: validPriorities.includes(rec?.priority) ? rec.priority : 'medium',
issue: rec?.issue || 'Mobile issue detected',
recommendation: rec?.recommendation || 'Improve mobile compatibility',
impact: rec?.impact || 'May affect mobile user experience'
}));
}
/**
* Score zu Grade konvertieren
*/
static scoreToGrade(score) {
if (score >= 90)
return 'A';
if (score >= 75)
return 'B';
if (score >= 60)
return 'C';
if (score >= 50)
return 'D';
return 'F';
}
/**
* Diagnose-Funktion: Analysiert Legacy-Daten auf Vollständigkeit
*/
static diagnoseLegacyData(legacyResult) {
const missingFields = [];
const warnings = [];
const pageAnalysis = [];
// Check metadata
if (!legacyResult.metadata)
missingFields.push('metadata');
if (!legacyResult.summary)
missingFields.push('summary');
if (!Array.isArray(legacyResult.pages))
missingFields.push('pages');
// Analyze each page
(legacyResult.pages || []).forEach((page) => {
const missingAnalyses = [];
if (!page.accessibility)
missingAnalyses.push('accessibility');
if (!page.performance)
missingAnalyses.push('performance');
if (!page.seo)
missingAnalyses.push('seo');
if (!page.contentWeight)
missingAnalyses.push('contentWeight');
if (!page.mobileFriendliness)
missingAnalyses.push('mobileFriendliness');
if (missingAnalyses.length > 0) {
pageAnalysis.push({
url: page.url || 'Unknown URL',
missingAnalyses
});
}
// Check for empty accessibility issues
if (page.accessibility) {
const hasIssues = (Array.isArray(page.accessibility.errors) && page.accessibility.errors.length > 0) ||
(Array.isArray(page.accessibility.warnings) && page.accessibility.warnings.length > 0) ||
(Array.isArray(page.accessibility.notices) && page.accessibility.notices.length > 0);
if (!hasIssues && (page.accessibility.score || 0) < 100) {
warnings.push(`Page ${page.url} has accessibility score ${page.accessibility.score} but no issues listed`);
}
}
});
return {
isComplete: missingFields.length === 0 && pageAnalysis.length === 0,
missingFields,
warnings,
pageAnalysis
};
}
}
exports.AuditDataAdapter = AuditDataAdapter;
// ============================================================================
// CONVENIENCE FUNCTIONS
// ============================================================================
/**
* High-level Convenience-Function: Konvertiert und validiert Legacy-Daten
*/
function convertAndValidateAuditData(legacyResult) {
console.log('🚀 Starting audit data conversion and validation...');
// First, diagnose the legacy data
const diagnosis = AuditDataAdapter.diagnoseLegacyData(legacyResult);
if (!diagnosis.isComplete) {
console.warn('⚠️ Legacy data is incomplete:');
console.warn(' Missing fields:', diagnosis.missingFields);
console.warn(' Incomplete pages:', diagnosis.pageAnalysis.length);
if (diagnosis.warnings.length > 0) {
console.warn(' Warnings:');
diagnosis.warnings.forEach(warning => console.warn(` - ${warning}`));
}
}
// Convert with adapter (which handles missing data gracefully)
const strictData = AuditDataAdapter.convertToStrict(legacyResult);
// Final validation
(0, strict_audit_validators_1.validateStrictAuditData)(strictData);
console.log('✅ Audit data conversion completed successfully');
return strictData;
}
/**
* Safe Conversion: Versucht Konvertierung, fängt Fehler ab
*/
function safeConvertAuditData(legacyResult) {
const warnings = [];
try {
const diagnosis = AuditDataAdapter.diagnoseLegacyData(legacyResult);
warnings.push(...diagnosis.warnings);
const strictData = AuditDataAdapter.convertToStrict(legacyResult);
return {
success: true,
data: strictData,
warnings
};
}
catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown conversion error',
warnings
};
}
}
//# sourceMappingURL=audit-data-adapter.js.map