@ai-growth/n8n-nodes-wordpress/dist/services/ImageUrlService.js

n8n node for WordPress integration with AI GROWTH - SEO WP plugin

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImageUrlService = exports.SUPPORTED_IMAGE_TYPES = void 0;
const url_1 = require("url");
const path_1 = require("path");
const ErrorUtils_1 = require("../utils/ErrorUtils");
/**
 * Tipos MIME suportados para imagens
 */
exports.SUPPORTED_IMAGE_TYPES = {
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.png': 'image/png',
    '.gif': 'image/gif',
    '.webp': 'image/webp',
    '.svg': 'image/svg+xml',
    '.bmp': 'image/bmp',
    '.tiff': 'image/tiff',
    '.tif': 'image/tiff'
};
/**
 * Serviço para validação e manipulação de URLs de imagens
 */
class ImageUrlService {
    /**
     * Valida uma URL de imagem
     * @param url URL da imagem para validar
     * @returns URL validada
     * @throws WordPressError se a URL for inválida
     */
    validateImageUrl(url) {
        try {
            // Verificar se a URL é válida
            const parsedUrl = new URL(url);
            // Verificar se a URL usa um protocolo suportado
            if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
                throw new ErrorUtils_1.WordPressError(`Protocolo não suportado: ${parsedUrl.protocol}`, ErrorUtils_1.WordPressErrorType.VALIDATION_FAILED);
            }
            // Verificar se o caminho termina com uma extensão de imagem suportada
            const extension = this.getExtensionFromUrl(url);
            if (!extension || !Object.keys(exports.SUPPORTED_IMAGE_TYPES).includes(extension.toLowerCase())) {
                throw new ErrorUtils_1.WordPressError(`Extensão de arquivo não suportada: ${extension || 'desconhecida'}`, ErrorUtils_1.WordPressErrorType.VALIDATION_FAILED);
            }
            return url;
        }
        catch (error) {
            if (error instanceof ErrorUtils_1.WordPressError) {
                throw error;
            }
            if (error instanceof TypeError && error.message.includes('Invalid URL')) {
                throw new ErrorUtils_1.WordPressError(`URL inválida: ${url}`, ErrorUtils_1.WordPressErrorType.VALIDATION_FAILED);
            }
            throw new ErrorUtils_1.WordPressError(`Erro ao validar URL de imagem: ${url}`, ErrorUtils_1.WordPressErrorType.UNKNOWN);
        }
    }
    /**
     * Obtém a extensão do arquivo a partir da URL
     * @param url URL da imagem
     * @returns Extensão do arquivo (com ponto) ou string vazia se não encontrada
     */
    getExtensionFromUrl(url) {
        try {
            const parsedUrl = (0, url_1.parse)(url);
            if (!parsedUrl.pathname) {
                return '';
            }
            // Remover parâmetros de consulta
            const path = parsedUrl.pathname.split('?')[0];
            // Obter extensão
            const extension = (0, path_1.extname)(path);
            return extension;
        }
        catch (error) {
            return '';
        }
    }
    /**
     * Obtém o tipo MIME a partir da extensão do arquivo
     * @param extension Extensão do arquivo (com ponto)
     * @returns Tipo MIME ou undefined se não suportado
     */
    getMimeTypeFromExtension(extension) {
        if (!extension) {
            return undefined;
        }
        const lowerExt = extension.toLowerCase();
        return exports.SUPPORTED_IMAGE_TYPES[lowerExt];
    }
    /**
     * Obtém o tipo MIME a partir da URL da imagem
     * @param url URL da imagem
     * @returns Tipo MIME ou undefined se não determinado
     */
    getMimeTypeFromUrl(url) {
        const extension = this.getExtensionFromUrl(url);
        return this.getMimeTypeFromExtension(extension);
    }
    /**
     * Extrai o nome do arquivo a partir da URL
     * @param url URL da imagem
     * @returns Nome do arquivo ou string vazia se não determinado
     */
    getFilenameFromUrl(url) {
        try {
            const parsedUrl = (0, url_1.parse)(url);
            if (!parsedUrl.pathname) {
                return '';
            }
            // Remover parâmetros de consulta
            const path = parsedUrl.pathname.split('?')[0];
            // Obter nome do arquivo (último segmento do caminho)
            const segments = path.split('/').filter(segment => segment.length > 0);
            if (segments.length === 0) {
                return '';
            }
            return segments[segments.length - 1];
        }
        catch (error) {
            return '';
        }
    }
    /**
     * Gera um nome de arquivo seguro a partir da URL
     * @param url URL da imagem
     * @param prefix Prefixo opcional para o nome do arquivo
     * @returns Nome de arquivo seguro
     */
    generateSafeFilename(url, prefix) {
        // Obter nome do arquivo original
        let filename = this.getFilenameFromUrl(url);
        if (!filename) {
            // Gerar nome aleatório se não for possível extrair da URL
            const timestamp = new Date().getTime();
            const random = Math.floor(Math.random() * 10000);
            const extension = this.getExtensionFromUrl(url) || '.jpg';
            filename = `image-${timestamp}-${random}${extension}`;
        }
        // Adicionar prefixo se fornecido
        if (prefix) {
            const extension = (0, path_1.extname)(filename);
            const baseName = filename.slice(0, filename.length - extension.length);
            filename = `${prefix}-${baseName}${extension}`;
        }
        // Sanitizar nome do arquivo (remover caracteres problemáticos)
        filename = filename
            .replace(/[^a-zA-Z0-9._-]/g, '-') // Substituir caracteres não alfanuméricos por hífens
            .replace(/-+/g, '-') // Substituir múltiplos hífens por um único
            .replace(/^-|-$/g, ''); // Remover hífens no início e fim
        return filename;
    }
}
exports.ImageUrlService = ImageUrlService;
//# sourceMappingURL=ImageUrlService.js.map