@cognima/banners 0.0.1-beta

package/src/effects.js

@@ -0,0 +1,355 @@
+"use strict";
+
+/**
+ * Módulo de Efeitos Visuais para @cognima/banners
+ * 
+ * Este módulo contém funções para aplicar efeitos visuais avançados aos banners,
+ * como gradientes, sombras, brilhos, padrões e outros efeitos decorativos.
+ * 
+ * @author Cognima Team (melhorado)
+ * @version 2.0.0
+ */
+
+const {
+    createLinearGradient,
+    hexToRgba,
+    roundRect
+} = require("../utils");
+
+/**
+ * Aplica um efeito de vidro fosco (glassmorphism)
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {number} radius - Raio dos cantos
+ * @param {number} opacity - Opacidade (0-1)
+ * @param {string} color - Cor base (hexadecimal)
+ */
+function applyGlassmorphism(ctx, x, y, width, height, radius = 10, opacity = 0.2, color = "#FFFFFF") {
+    // Fundo semi-transparente
+    ctx.fillStyle = hexToRgba(color, opacity);
+    roundRect(ctx, x, y, width, height, radius, true, false);
+    
+    // Borda sutil
+    ctx.strokeStyle = hexToRgba(color, opacity + 0.1);
+    ctx.lineWidth = 1;
+    roundRect(ctx, x, y, width, height, radius, false, true);
+    
+    // Brilho superior (efeito de vidro)
+    const gradient = createLinearGradient(
+        ctx,
+        x,
+        y,
+        x,
+        y + height * 0.5,
+        hexToRgba(color, opacity + 0.1),
+        hexToRgba(color, 0),
+        "vertical"
+    );
+    
+    ctx.fillStyle = gradient;
+    roundRect(ctx, x, y, width, height * 0.5, { tl: radius, tr: radius, br: 0, bl: 0 }, true, false);
+}
+
+/**
+ * Aplica um efeito de neomorfismo
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {number} radius - Raio dos cantos
+ * @param {string} baseColor - Cor base (hexadecimal)
+ * @param {boolean} pressed - Se o elemento está pressionado
+ */
+function applyNeomorphism(ctx, x, y, width, height, radius = 10, baseColor = "#E0E0E0", pressed = false) {
+    // Salva o estado atual
+    ctx.save();
+    
+    // Desenha o fundo base
+    ctx.fillStyle = baseColor;
+    roundRect(ctx, x, y, width, height, radius, true, false);
+    
+    if (pressed) {
+        // Efeito pressionado (sombra interna)
+        ctx.shadowColor = "rgba(0, 0, 0, 0.2)";
+        ctx.shadowBlur = 15;
+        ctx.shadowOffsetX = 5;
+        ctx.shadowOffsetY = 5;
+        roundRect(ctx, x + 2, y + 2, width - 4, height - 4, radius - 2, false, true);
+        
+        ctx.shadowColor = "rgba(255, 255, 255, 0.7)";
+        ctx.shadowOffsetX = -5;
+        ctx.shadowOffsetY = -5;
+        roundRect(ctx, x + 2, y + 2, width - 4, height - 4, radius - 2, false, true);
+    } else {
+        // Efeito normal (sombra externa)
+        ctx.shadowColor = "rgba(0, 0, 0, 0.2)";
+        ctx.shadowBlur = 15;
+        ctx.shadowOffsetX = 5;
+        ctx.shadowOffsetY = 5;
+        roundRect(ctx, x, y, width, height, radius, false, true);
+        
+        ctx.shadowColor = "rgba(255, 255, 255, 0.7)";
+        ctx.shadowOffsetX = -5;
+        ctx.shadowOffsetY = -5;
+        roundRect(ctx, x, y, width, height, radius, false, true);
+    }
+    
+    // Restaura o estado
+    ctx.restore();
+}
+
+/**
+ * Aplica um efeito de gradiente com várias cores
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {Array} colors - Array de cores (hexadecimal)
+ * @param {string} direction - Direção do gradiente ('horizontal', 'vertical', 'diagonal', 'radial')
+ */
+function applyMultiColorGradient(ctx, x, y, width, height, colors, direction = 'horizontal') {
+    if (!colors || colors.length < 2) {
+        throw new Error("São necessárias pelo menos duas cores para criar um gradiente.");
+    }
+    
+    let gradient;
+    
+    if (direction === 'radial') {
+        // Gradiente radial
+        const centerX = x + width / 2;
+        const centerY = y + height / 2;
+        const radius = Math.max(width, height) / 2;
+        
+        gradient = ctx.createRadialGradient(centerX, centerY, 0, centerX, centerY, radius);
+    } else {
+        // Gradiente linear
+        switch (direction) {
+            case 'horizontal':
+                gradient = ctx.createLinearGradient(x, y, x + width, y);
+                break;
+            case 'vertical':
+                gradient = ctx.createLinearGradient(x, y, x, y + height);
+                break;
+            case 'diagonal':
+            default:
+                gradient = ctx.createLinearGradient(x, y, x + width, y + height);
+                break;
+        }
+    }
+    
+    // Adiciona as cores ao gradiente
+    const step = 1 / (colors.length - 1);
+    colors.forEach((color, index) => {
+        gradient.addColorStop(index * step, color);
+    });
+    
+    return gradient;
+}
+
+/**
+ * Aplica um efeito de padrão de pontos
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {number} spacing - Espaçamento entre os pontos
+ * @param {number} radius - Raio dos pontos
+ * @param {string} color - Cor dos pontos (hexadecimal)
+ * @param {number} opacity - Opacidade dos pontos (0-1)
+ */
+function applyDotPattern(ctx, x, y, width, height, spacing = 20, radius = 2, color = "#000000", opacity = 0.2) {
+    // Salva o estado atual
+    ctx.save();
+    
+    // Define a cor e opacidade
+    ctx.fillStyle = hexToRgba(color, opacity);
+    
+    // Desenha os pontos
+    for (let posX = x; posX < x + width; posX += spacing) {
+        for (let posY = y; posY < y + height; posY += spacing) {
+            ctx.beginPath();
+            ctx.arc(posX, posY, radius, 0, Math.PI * 2);
+            ctx.fill();
+        }
+    }
+    
+    // Restaura o estado
+    ctx.restore();
+}
+
+/**
+ * Aplica um efeito de padrão de linhas
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {number} spacing - Espaçamento entre as linhas
+ * @param {number} lineWidth - Largura das linhas
+ * @param {string} color - Cor das linhas (hexadecimal)
+ * @param {number} opacity - Opacidade das linhas (0-1)
+ * @param {string} direction - Direção das linhas ('horizontal', 'vertical', 'diagonal')
+ */
+function applyLinePattern(ctx, x, y, width, height, spacing = 20, lineWidth = 1, color = "#000000", opacity = 0.2, direction = 'horizontal') {
+    // Salva o estado atual
+    ctx.save();
+    
+    // Define a cor, opacidade e largura da linha
+    ctx.strokeStyle = hexToRgba(color, opacity);
+    ctx.lineWidth = lineWidth;
+    
+    // Desenha as linhas
+    switch (direction) {
+        case 'vertical':
+            for (let posX = x; posX < x + width; posX += spacing) {
+                ctx.beginPath();
+                ctx.moveTo(posX, y);
+                ctx.lineTo(posX, y + height);
+                ctx.stroke();
+            }
+            break;
+        case 'diagonal':
+            const diagonal = Math.sqrt(width * width + height * height);
+            const steps = diagonal / spacing;
+            const stepX = width / steps;
+            const stepY = height / steps;
+            
+            for (let i = -steps; i <= steps * 2; i++) {
+                ctx.beginPath();
+                ctx.moveTo(x + i * stepX, y);
+                ctx.lineTo(x, y + i * stepY);
+                ctx.stroke();
+            }
+            break;
+        case 'horizontal':
+        default:
+            for (let posY = y; posY < y + height; posY += spacing) {
+                ctx.beginPath();
+                ctx.moveTo(x, posY);
+                ctx.lineTo(x + width, posY);
+                ctx.stroke();
+            }
+            break;
+    }
+    
+    // Restaura o estado
+    ctx.restore();
+}
+
+/**
+ * Aplica um efeito de brilho (glow)
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {number} radius - Raio dos cantos
+ * @param {string} color - Cor do brilho (hexadecimal)
+ * @param {number} blurSize - Tamanho do desfoque
+ */
+function applyGlow(ctx, x, y, width, height, radius = 10, color = "#3498DB", blurSize = 20) {
+    // Salva o estado atual
+    ctx.save();
+    
+    // Aplica o efeito de brilho
+    ctx.shadowColor = color;
+    ctx.shadowBlur = blurSize;
+    ctx.shadowOffsetX = 0;
+    ctx.shadowOffsetY = 0;
+    
+    // Desenha a forma com o brilho
+    ctx.fillStyle = color;
+    roundRect(ctx, x, y, width, height, radius, true, false);
+    
+    // Restaura o estado
+    ctx.restore();
+}
+
+/**
+ * Aplica um efeito de textura de ruído
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {number} width - Largura
+ * @param {number} height - Altura
+ * @param {number} opacity - Opacidade do ruído (0-1)
+ * @param {string} color - Cor do ruído (hexadecimal)
+ */
+function applyNoiseTexture(ctx, x, y, width, height, opacity = 0.1, color = "#000000") {
+    // Usa pureimage para criar um canvas temporário (compatível com Node.js)
+    const pureimage = require("pureimage");
+    const tempCanvas = pureimage.make(Math.ceil(width), Math.ceil(height));
+    const tempCtx = tempCanvas.getContext('2d');
+    
+    // Obtém os dados da imagem do canvas temporário
+    const imageData = tempCtx.getImageData(0, 0, Math.ceil(width), Math.ceil(height));
+    const data = imageData.data;
+    
+    // Preenche os dados com ruído
+    for (let i = 0; i < data.length; i += 4) {
+        const value = Math.random() * 255;
+        data[i] = value;     // R
+        data[i + 1] = value; // G
+        data[i + 2] = value; // B
+        data[i + 3] = Math.floor(Math.random() * 255 * opacity); // A
+    }
+    
+    // Aplica os dados da imagem
+    tempCtx.putImageData(imageData, 0, 0);
+    
+    // Desenha o ruído no contexto principal
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    ctx.drawImage(tempCanvas, x, y, width, height);
+    ctx.restore();
+}
+
+/**
+ * Aplica um efeito de recorte de imagem em forma de texto
+ * @param {Object} ctx - Contexto de renderização 2D
+ * @param {string} text - Texto a ser usado como máscara
+ * @param {number} x - Posição X
+ * @param {number} y - Posição Y
+ * @param {Object} image - Imagem a ser recortada
+ * @param {string} font - Fonte do texto
+ */
+function applyTextClipping(ctx, text, x, y, image, font) {
+    // Salva o estado atual
+    ctx.save();
+    
+    // Define a fonte
+    ctx.font = font;
+    
+    // Cria o caminho do texto
+    ctx.fillStyle = "#000000";
+    ctx.textBaseline = "top";
+    ctx.fillText(text, x, y);
+    
+    // Usa o texto como máscara de recorte
+    ctx.globalCompositeOperation = "source-in";
+    
+    // Desenha a imagem
+    ctx.drawImage(image, x, y);
+    
+    // Restaura o estado
+    ctx.restore();
+}
+
+// --- Exportações ---
+module.exports = {
+    applyGlassmorphism,
+    applyNeomorphism,
+    applyMultiColorGradient,
+    applyDotPattern,
+    applyLinePattern,
+    applyGlow,
+    applyNoiseTexture,
+    applyTextClipping
+};
+

package/src/error-handler.js

@@ -0,0 +1,305 @@
+"use strict";
+
+/**
+ * Módulo de tratamento de erros
+ * 
+ * Este módulo fornece funções para tratar erros do módulo @cognima/banners.
+ * 
+ * @module error-handler
+ * @author Cognima Team (melhorado)
+ * @version 2.0.0
+ */
+
+// Configuração padrão
+let config = {
+    debug: false, // Se deve mostrar mensagens de debug
+    logErrors: true, // Se deve registrar erros no console
+    throwErrors: true, // Se deve lançar erros
+    useErrorCodes: true, // Se deve usar códigos de erro
+    useErrorTranslation: true, // Se deve traduzir mensagens de erro
+    language: 'pt-BR' // Idioma padrão para mensagens de erro
+};
+
+// Códigos de erro
+const errorCodes = {
+    INVALID_PARAMETER: 'ERR_INVALID_PARAMETER',
+    MISSING_PARAMETER: 'ERR_MISSING_PARAMETER',
+    IMAGE_LOAD_ERROR: 'ERR_IMAGE_LOAD',
+    IMAGE_PROCESS_ERROR: 'ERR_IMAGE_PROCESS',
+    BANNER_CREATION_ERROR: 'ERR_BANNER_CREATION',
+    INTERNAL_ERROR: 'ERR_INTERNAL',
+    FILE_SYSTEM_ERROR: 'ERR_FILE_SYSTEM',
+    NETWORK_ERROR: 'ERR_NETWORK',
+    CACHE_ERROR: 'ERR_CACHE',
+    OPTIMIZATION_ERROR: 'ERR_OPTIMIZATION'
+};
+
+// Traduções de mensagens de erro
+const errorTranslations = {
+    'pt-BR': {
+        [errorCodes.INVALID_PARAMETER]: 'Parâmetro inválido: {0}',
+        [errorCodes.MISSING_PARAMETER]: 'Parâmetro obrigatório ausente: {0}',
+        [errorCodes.IMAGE_LOAD_ERROR]: 'Erro ao carregar imagem: {0}',
+        [errorCodes.IMAGE_PROCESS_ERROR]: 'Erro ao processar imagem: {0}',
+        [errorCodes.BANNER_CREATION_ERROR]: 'Erro ao criar banner: {0}',
+        [errorCodes.INTERNAL_ERROR]: 'Erro interno: {0}',
+        [errorCodes.FILE_SYSTEM_ERROR]: 'Erro de sistema de arquivos: {0}',
+        [errorCodes.NETWORK_ERROR]: 'Erro de rede: {0}',
+        [errorCodes.CACHE_ERROR]: 'Erro de cache: {0}',
+        [errorCodes.OPTIMIZATION_ERROR]: 'Erro de otimização: {0}'
+    },
+    'en-US': {
+        [errorCodes.INVALID_PARAMETER]: 'Invalid parameter: {0}',
+        [errorCodes.MISSING_PARAMETER]: 'Missing required parameter: {0}',
+        [errorCodes.IMAGE_LOAD_ERROR]: 'Error loading image: {0}',
+        [errorCodes.IMAGE_PROCESS_ERROR]: 'Error processing image: {0}',
+        [errorCodes.BANNER_CREATION_ERROR]: 'Error creating banner: {0}',
+        [errorCodes.INTERNAL_ERROR]: 'Internal error: {0}',
+        [errorCodes.FILE_SYSTEM_ERROR]: 'File system error: {0}',
+        [errorCodes.NETWORK_ERROR]: 'Network error: {0}',
+        [errorCodes.CACHE_ERROR]: 'Cache error: {0}',
+        [errorCodes.OPTIMIZATION_ERROR]: 'Optimization error: {0}'
+    }
+};
+
+/**
+ * Formata uma mensagem de erro
+ * 
+ * @param {string} template - Template da mensagem
+ * @param {Array<string>} args - Argumentos para substituir no template
+ * @returns {string} - Mensagem formatada
+ */
+function formatMessage(template, args) {
+    if (!args || !args.length) return template;
+    
+    return template.replace(/\{(\d+)\}/g, (match, index) => {
+        const argIndex = parseInt(index, 10);
+        return argIndex < args.length ? args[argIndex] : match;
+    });
+}
+
+/**
+ * Traduz uma mensagem de erro
+ * 
+ * @param {string} code - Código de erro
+ * @param {Array<string>} args - Argumentos para substituir no template
+ * @returns {string} - Mensagem traduzida
+ */
+function translateError(code, args) {
+    if (!config.useErrorTranslation) return code;
+    
+    const translations = errorTranslations[config.language] || errorTranslations['en-US'];
+    const template = translations[code] || code;
+    
+    return formatMessage(template, args);
+}
+
+/**
+ * Cria um objeto de erro
+ * 
+ * @param {string} code - Código de erro
+ * @param {string} message - Mensagem de erro
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function createError(code, message, originalError) {
+    const error = new Error(message);
+    error.code = code;
+    error.originalError = originalError;
+    return error;
+}
+
+/**
+ * Trata um erro
+ * 
+ * @param {string} code - Código de erro
+ * @param {Array<string>} args - Argumentos para substituir no template
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleError(code, args, originalError) {
+    // Obtém a mensagem traduzida
+    const message = translateError(code, args);
+    
+    // Cria o objeto de erro
+    const error = createError(config.useErrorCodes ? code : undefined, message, originalError);
+    
+    // Registra o erro no console
+    if (config.logErrors) {
+        console.error(`[${code}] ${message}`);
+        
+        if (config.debug && originalError) {
+            console.error('Erro original:', originalError);
+        }
+    }
+    
+    // Lança o erro se necessário
+    if (config.throwErrors) {
+        throw error;
+    }
+    
+    return error;
+}
+
+/**
+ * Trata um erro de parâmetro inválido
+ * 
+ * @param {string} paramName - Nome do parâmetro
+ * @param {string} [reason] - Motivo da invalidação
+ * @returns {Error} - Objeto de erro
+ */
+function handleInvalidParameter(paramName, reason) {
+    const args = [paramName];
+    if (reason) args.push(reason);
+    return handleError(errorCodes.INVALID_PARAMETER, args);
+}
+
+/**
+ * Trata um erro de parâmetro ausente
+ * 
+ * @param {string} paramName - Nome do parâmetro
+ * @returns {Error} - Objeto de erro
+ */
+function handleMissingParameter(paramName) {
+    return handleError(errorCodes.MISSING_PARAMETER, [paramName]);
+}
+
+/**
+ * Trata um erro de carregamento de imagem
+ * 
+ * @param {string} url - URL da imagem
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleImageLoadError(url, originalError) {
+    return handleError(errorCodes.IMAGE_LOAD_ERROR, [url], originalError);
+}
+
+/**
+ * Trata um erro de processamento de imagem
+ * 
+ * @param {string} operation - Operação de processamento
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleImageProcessError(operation, originalError) {
+    return handleError(errorCodes.IMAGE_PROCESS_ERROR, [operation], originalError);
+}
+
+/**
+ * Trata um erro de criação de banner
+ * 
+ * @param {string} bannerType - Tipo de banner
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleBannerCreationError(bannerType, originalError) {
+    return handleError(errorCodes.BANNER_CREATION_ERROR, [bannerType], originalError);
+}
+
+/**
+ * Trata um erro interno
+ * 
+ * @param {string} message - Mensagem de erro
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleInternalError(message, originalError) {
+    return handleError(errorCodes.INTERNAL_ERROR, [message], originalError);
+}
+
+/**
+ * Trata um erro de sistema de arquivos
+ * 
+ * @param {string} operation - Operação de sistema de arquivos
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleFileSystemError(operation, originalError) {
+    return handleError(errorCodes.FILE_SYSTEM_ERROR, [operation], originalError);
+}
+
+/**
+ * Trata um erro de rede
+ * 
+ * @param {string} url - URL da requisição
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleNetworkError(url, originalError) {
+    return handleError(errorCodes.NETWORK_ERROR, [url], originalError);
+}
+
+/**
+ * Trata um erro de cache
+ * 
+ * @param {string} operation - Operação de cache
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleCacheError(operation, originalError) {
+    return handleError(errorCodes.CACHE_ERROR, [operation], originalError);
+}
+
+/**
+ * Trata um erro de otimização
+ * 
+ * @param {string} operation - Operação de otimização
+ * @param {Error} [originalError] - Erro original
+ * @returns {Error} - Objeto de erro
+ */
+function handleOptimizationError(operation, originalError) {
+    return handleError(errorCodes.OPTIMIZATION_ERROR, [operation], originalError);
+}
+
+/**
+ * Define se o modo de debug está habilitado
+ * 
+ * @param {boolean} debug - Se o modo de debug está habilitado
+ */
+function setDebug(debug) {
+    config.debug = debug;
+}
+
+/**
+ * Configura as opções de tratamento de erros
+ * 
+ * @param {Object} options - Opções de configuração
+ * @param {boolean} [options.debug] - Se deve mostrar mensagens de debug
+ * @param {boolean} [options.logErrors] - Se deve registrar erros no console
+ * @param {boolean} [options.throwErrors] - Se deve lançar erros
+ * @param {boolean} [options.useErrorCodes] - Se deve usar códigos de erro
+ * @param {boolean} [options.useErrorTranslation] - Se deve traduzir mensagens de erro
+ * @param {string} [options.language] - Idioma para mensagens de erro
+ */
+function configure(options) {
+    config = { ...config, ...options };
+}
+
+/**
+ * Obtém a configuração atual
+ * 
+ * @returns {Object} - Configuração atual
+ */
+function getConfig() {
+    return { ...config };
+}
+
+module.exports = {
+    errorCodes,
+    handleError,
+    handleInvalidParameter,
+    handleMissingParameter,
+    handleImageLoadError,
+    handleImageProcessError,
+    handleBannerCreationError,
+    handleInternalError,
+    handleFileSystemError,
+    handleNetworkError,
+    handleCacheError,
+    handleOptimizationError,
+    setDebug,
+    configure,
+    getConfig
+};
+