@bramato/openrouter-mock-generator
Version:
AI-powered mock data generator using OpenRouter API with JSON mode support
234 lines • 7.92 kB
JavaScript
;
/**
* Microservizio per estrarre URLs di immagini Picsum dai dati JSON
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImageUrlExtractor = void 0;
class ImageUrlExtractor {
/**
* Estrae tutti gli URL Picsum da un oggetto JSON
*/
static extractPicsumUrls(data) {
const images = [];
const uniqueUrls = new Set();
const duplicateGroups = new Map();
this.traverseObject(data, '', images, 0);
// Raggruppa per URL duplicati (stesse dimensioni/seed)
images.forEach(img => {
const normalizedUrl = this.normalizeUrl(img.url);
if (!duplicateGroups.has(normalizedUrl)) {
duplicateGroups.set(normalizedUrl, []);
}
duplicateGroups.get(normalizedUrl).push(img);
uniqueUrls.add(normalizedUrl);
});
return {
images,
totalFound: images.length,
uniqueUrls: uniqueUrls.size,
duplicateGroups,
};
}
/**
* Attraversa ricorsivamente un oggetto JSON per trovare URL Picsum
*/
static traverseObject(obj, currentPath, results, itemIndex) {
if (!obj || typeof obj !== 'object')
return;
if (Array.isArray(obj)) {
obj.forEach((item, index) => {
const newPath = currentPath ? `${currentPath}[${index}]` : `[${index}]`;
this.traverseObject(item, newPath, results, index);
});
}
else {
Object.entries(obj).forEach(([key, value]) => {
const newPath = currentPath ? `${currentPath}.${key}` : key;
if (typeof value === 'string' && this.isPicsumUrl(value)) {
const imageInfo = this.parseImageUrl(value, newPath, key, obj, itemIndex);
if (imageInfo) {
results.push(imageInfo);
}
}
else if (typeof value === 'object') {
this.traverseObject(value, newPath, results, itemIndex);
}
});
}
}
/**
* Verifica se una stringa è un URL Picsum
*/
static isPicsumUrl(url) {
return this.PICSUM_PATTERNS.some(pattern => {
pattern.lastIndex = 0; // Reset regex state
return pattern.test(url);
});
}
/**
* Parsea un URL Picsum ed estrae le informazioni
*/
static parseImageUrl(url, path, fieldName, context, itemIndex) {
const dimensions = this.extractDimensions(url);
const seed = this.extractSeed(url);
if (!dimensions)
return null;
return {
url,
path,
fieldName,
context,
dimensions,
seed,
itemIndex,
};
}
/**
* Estrae le dimensioni da un URL Picsum
*/
static extractDimensions(url) {
// Pattern con larghezza e altezza: https://picsum.photos/800/600
let match = url.match(/picsum\.photos\/(\d+)\/(\d+)/);
if (match) {
return {
width: parseInt(match[1]),
height: parseInt(match[2]),
};
}
// Pattern con seed: https://picsum.photos/seed/milano/800/600
match = url.match(/picsum\.photos\/seed\/[^\/]+\/(\d+)\/(\d+)/);
if (match) {
return {
width: parseInt(match[1]),
height: parseInt(match[2]),
};
}
// Pattern solo larghezza (quadrata): https://picsum.photos/400
match = url.match(/picsum\.photos\/(\d+)(?:\?|$)/);
if (match) {
const size = parseInt(match[1]);
return {
width: size,
height: size,
};
}
return null;
}
/**
* Estrae il seed da un URL Picsum
*/
static extractSeed(url) {
const match = url.match(/picsum\.photos\/seed\/([^\/\?]+)/);
return match ? match[1] : undefined;
}
/**
* Normalizza un URL per il confronto
*/
static normalizeUrl(url) {
return url.replace(/\?.*$/, '').toLowerCase();
}
/**
* Raggruppa immagini per dimensioni simili
*/
static groupBySimilarDimensions(images) {
const groups = new Map();
images.forEach(img => {
const key = `${img.dimensions.width}x${img.dimensions.height}`;
if (!groups.has(key)) {
groups.set(key, []);
}
groups.get(key).push(img);
});
return groups;
}
/**
* Filtra immagini per tipo di campo
*/
static filterByFieldType(images) {
const result = {
thumbnails: [],
banners: [],
squares: [],
portraits: [],
landscapes: [],
generic: [],
};
images.forEach(img => {
const fieldName = img.fieldName.toLowerCase();
const { width, height } = img.dimensions;
const ratio = width / height;
if (fieldName.includes('thumb')) {
result.thumbnails.push(img);
}
else if (fieldName.includes('banner') || fieldName.includes('header')) {
result.banners.push(img);
}
else if (ratio === 1) {
result.squares.push(img);
}
else if (ratio < 1) {
result.portraits.push(img);
}
else if (ratio > 2) {
result.banners.push(img);
}
else if (ratio > 1) {
result.landscapes.push(img);
}
else {
result.generic.push(img);
}
});
return result;
}
/**
* Statistiche di estrazione
*/
static getExtractionStats(result) {
const dimensionDistribution = new Map();
const fieldTypeDistribution = new Map();
let duplicateCount = 0;
result.images.forEach(img => {
const dimKey = `${img.dimensions.width}x${img.dimensions.height}`;
dimensionDistribution.set(dimKey, (dimensionDistribution.get(dimKey) || 0) + 1);
const fieldType = this.getFieldType(img.fieldName);
fieldTypeDistribution.set(fieldType, (fieldTypeDistribution.get(fieldType) || 0) + 1);
});
result.duplicateGroups.forEach(group => {
if (group.length > 1) {
duplicateCount += group.length - 1;
}
});
const summary = `Trovate ${result.totalFound} immagini Picsum, ${result.uniqueUrls} uniche, ${duplicateCount} duplicate`;
return {
summary,
dimensionDistribution,
fieldTypeDistribution,
duplicateCount,
};
}
static getFieldType(fieldName) {
const name = fieldName.toLowerCase();
if (name.includes('thumb'))
return 'thumbnail';
if (name.includes('banner') || name.includes('header'))
return 'banner';
if (name.includes('avatar') || name.includes('profile'))
return 'avatar';
if (name.includes('logo'))
return 'logo';
if (name.includes('background') || name.includes('bg'))
return 'background';
if (name.includes('gallery') || name.includes('photo'))
return 'gallery';
return 'generic';
}
}
exports.ImageUrlExtractor = ImageUrlExtractor;
ImageUrlExtractor.PICSUM_PATTERNS = [
/https?:\/\/picsum\.photos\/(\d+)\/(\d+)(?:\?.*)?/gi,
/https?:\/\/picsum\.photos\/(\d+)(?:\?.*)?/gi,
/https?:\/\/picsum\.photos\/seed\/([^\/]+)\/(\d+)\/(\d+)(?:\?.*)?/gi,
/https?:\/\/picsum\.photos\/v2\/list(?:\?.*)?/gi,
];
//# sourceMappingURL=image-url-extractor.js.map