neekuro 2.0.4 → 2.2.0

package/sources/classes/package/{Welcome.js → welcome.js}

@@ -2,7 +2,15 @@
 const Canvas = require('canvas');
 const NekoError = require('../errors/Error.js');
 const hex_reg = require('hex-color-regex')({ strict: true })
-const path = require('path');
+const path = require('path');
+const fs = require('fs');
+const { loadImageSource, parseRemoteURL, validateImageBuffer } = require('../../utils/imageLoader.js');
+
+const DEFAULT_WIDTH = 1140;
+const DEFAULT_HEIGHT = 520;
+const MIN_DIMENSION = 128;
+const MAX_DIMENSION = 4096;
+const registeredFonts = new Set();
 
 /**
  * @typedef {import('../../typings').FontNames} FontNames
@@ -29,7 +37,8 @@ class Welcome {
     constructor() {
         /**
          * @property {Object} data - Configuración actual de la imagen
-         * @property {string} data.font - Fuente actualmente seleccionada
+         * @property {string} data.font - Fuente actualmente seleccionada
+         * @property {'center'|'manual'} data.layout - Distribución de los elementos
          * @property {number} data.width - Ancho actual de la imagen
          * @property {number} data.height - Alto actual de la imagen
          * @property {Object} data.background - Configuración del fondo
@@ -54,10 +63,11 @@ class Welcome {
          * @property {number} data.description.font_size - Tamaño de fuente de la descripción
          * @property {string} data.description.text_color - Color del texto de la descripción
          */
-        this.data = {
-            font: 'arial',
-            width: 1140,
-            height: 520,
+        this.data = {
+            font: 'arial',
+            layout: 'center',
+            width: DEFAULT_WIDTH,
+            height: DEFAULT_HEIGHT,
             background: {
                 type: 'color',
                 value: '#23272A'
@@ -83,8 +93,9 @@ class Welcome {
                 font_size: 35,
                 text_color: "#F7F7F7"
             }
-        }
-    }
+        }
+        this.setFont('arial');
+    }
 
     /**
      * Establece la resolución de la imagen de bienvenida
@@ -99,22 +110,28 @@ class Welcome {
      * // Restablecer a valores por defecto
      * welcome.setResolution('default', 'default');
      */
-    setResolution(width, height) {
+    setResolution(width, height) {
         if (!width) throw new NekoError('ResolutionError', 'el parametro <width> no puede quedar vacio');
         if (!height) throw new NekoError('ResolutionError', 'el parametro <height> no puede quedar vacio');
 
-        if (width == 'default') width = this.data.width; else {
-            if (typeof width != 'number') throw new NekoError('TypeError', 'el parametro <width> solo acepta tipo \'number\', recibió ' + typeof width);
-            this.data.width = width;
-        }
-
-        if (height == 'default') height = this.data.height; else {
-            if (typeof height != 'number') throw new NekoError('TypeError', 'el parametro <height> solo acepta tipo \'number\', recibió ' + typeof height);
-            this.data.height = height;
-        }
-
-        return this
-    }
+        this.data.width = width === 'default' ? DEFAULT_WIDTH : validateDimension(width, 'width');
+        this.data.height = height === 'default' ? DEFAULT_HEIGHT : validateDimension(height, 'height');
+
+        return this
+    }
+
+    /**
+     * Selecciona la distribución automática centrada o las coordenadas manuales.
+     * @param {'center'|'manual'} layout
+     * @returns {Welcome}
+     */
+    setLayout(layout) {
+        if (!['center', 'manual'].includes(layout)) {
+            throw new NekoError('LayoutError', 'El layout debe ser "center" o "manual"');
+        }
+        this.data.layout = layout;
+        return this;
+    }
 
     /**
      * Configura la tipografía para el texto de la imagen
@@ -145,13 +162,18 @@ class Welcome {
             case 'custom':
                 if (!dir) throw new NekoError('FontError', 'el parametro <dir> no puede quedar vacio en un tipo de fuente customizada');
                 if (typeof dir != 'string') throw new NekoError('TypeError', 'el parametro <dir> solo acepta tipo \'string\', recibió ' + typeof dir);
-                if (!dir.endsWith('ttf')) throw new NekoError('FontError', 'se nesecita un archivo ttf en el parametro <dir>')
-                ruta = path.join(__dirname, '../../../../' + dir.replace('./', ''));
+                if (path.extname(dir).toLowerCase() !== '.ttf') throw new NekoError('FontError', 'se necesita un archivo TTF en el parametro <dir>')
+                ruta = path.resolve(dir);
                 break;
             default: throw new NekoError('FontError', 'el parametro <name> no acepta ningun tipo diferente a los preterminados');
         }
         try {
-            Canvas.registerFont(ruta, { family: name })
+            if (!fs.existsSync(ruta)) throw new Error('Font not found');
+            const fontKey = `${name}:${ruta}`;
+            if (!registeredFonts.has(fontKey)) {
+                Canvas.registerFont(ruta, { family: name });
+                registeredFonts.add(fontKey);
+            }
         } catch (error) {
             throw new NekoError('DirError', 'no se puede encontrar el directorio especificado')
         }
@@ -206,18 +228,20 @@ class Welcome {
             }
 
             // validacion de posiciones
-            if (data.x) {
+            if (data.x !== undefined) {
                 if (typeof data.x !== 'number') {
                     throw new NekoError('TypeError', `La propiedad <x> solo acepta tipo 'number', recibió ${typeof data.x}`);
                 }
-                this.data.title.x = data.x;
+                this.data.title.x = data.x;
+                this.data.layout = 'manual';
             }
 
-            if (data.y) {
+            if (data.y !== undefined) {
                 if (typeof data.y !== 'number') {
                     throw new NekoError('TypeError', `La propiedad <y> solo acepta tipo 'number', recibió ${typeof data.y}`);
                 }
-                this.data.title.y = data.y;
+                this.data.title.y = data.y;
+                this.data.layout = 'manual';
             }
         }
 
@@ -270,18 +294,20 @@ class Welcome {
             }
 
             // validacion de posiciones
-            if (data.x) {
+            if (data.x !== undefined) {
                 if (typeof data.x !== 'number') {
                     throw new NekoError('TypeError', `La propiedad <x> solo acepta tipo 'number', recibió ${typeof data.x}`);
                 }
-                this.data.description.x = data.x;
+                this.data.description.x = data.x;
+                this.data.layout = 'manual';
             }
 
-            if (data.y) {
+            if (data.y !== undefined) {
                 if (typeof data.y !== 'number') {
                     throw new NekoError('TypeError', `La propiedad <y> solo acepta tipo 'number', recibió ${typeof data.y}`);
                 }
-                this.data.description.y = data.y;
+                this.data.description.y = data.y;
+                this.data.layout = 'manual';
             }
         }
 
@@ -327,11 +353,9 @@ class Welcome {
             }
 
             if (typeof value == 'string') {
-                try {
-                    new URL(value);
-                } catch (error) {
-                    throw new NekoError('BackgroundError', 'La URL proporcionada no es válida');
-                }
+                parseRemoteURL(value, 'el fondo');
+            } else {
+                validateImageBuffer(value, 'el fondo');
             }
 
             this.data.background = { type, value };
@@ -369,56 +393,33 @@ class Welcome {
         }
 
         if (typeof source === 'string') {
-            try {
-                const url = new URL(source);
-                
-                if (!['http:', 'https:'].includes(url.protocol)) {
-                    throw new NekoError('AvatarError', 'La URL debe usar HTTP/HTTPS');
-                }
-
-                const extension = url.pathname.toLowerCase().split('.').pop();
-                if (!['jpg', 'jpeg', 'png', 'gif'].includes(extension)) {
-                    throw new NekoError('AvatarError', 'Formato de imagen no soportado. Usa JPEG, PNG o GIF');
-                }
-            } catch (error) {
-                if (error instanceof NekoError) throw error;
-                throw new NekoError('AvatarError', 'La URL del avatar no es válida');
-            }
+            parseRemoteURL(source, 'el avatar');
         }
         
         if (Buffer.isBuffer(source)) {
-            if (source.length < 8) { 
-                throw new NekoError('AvatarError', 'El Buffer de imagen es demasiado pequeño');
-            }
-            
-            const header = source.toString('hex', 0, 8);
-            const isJPEG = header.startsWith('ffd8ff');
-            const isPNG = header.startsWith('89504e470d0a1a0a');
-            const isGIF = header.startsWith('47494638');
-            
-            if (!isJPEG && !isPNG && !isGIF) {
-                throw new NekoError('AvatarError', 'Formato de imagen no soportado. El Buffer debe ser JPEG, PNG o GIF');
-            }
+            validateImageBuffer(source, 'el avatar');
         }
     
         this.data.avatar.source = source;
 
         if (data) {
-            if (data.x) {
+            if (data.x !== undefined) {
                 if (typeof data.x != 'number') {
                     throw new NekoError('TypeError', 'La propiedad <x> debe ser un número');
                 }
                 if (data.x < 0) {
                     throw new NekoError('AvatarError', 'La posición X no puede ser negativa');
                 }
-                this.data.avatar.x = data.x;
+                this.data.avatar.x = data.x;
+                this.data.layout = 'manual';
             }
 
-            if (data.y) {
+            if (data.y !== undefined) {
                 if (typeof data.y != 'number') {
                     throw new NekoError('TypeError', 'La propiedad <y> debe ser un número');
                 }
-                this.data.avatar.y = data.y;
+                this.data.avatar.y = data.y;
+                this.data.layout = 'manual';
             }
 
             if (data.border) {
@@ -434,10 +435,13 @@ class Welcome {
                 this.data.avatar.border = data.border;
             }
 
-            if (data.radio) {
-                if (typeof data.radio != 'number') {
-                    throw new NekoError('TypeError', 'La propiedad <radio> debe ser un número');
-                }
+            if (data.radio !== undefined) {
+                if (typeof data.radio != 'number') {
+                    throw new NekoError('TypeError', 'La propiedad <radio> debe ser un número');
+                }
+                if (!Number.isFinite(data.radio) || data.radio <= 0 || data.radio > Math.min(this.data.width, this.data.height) / 2) {
+                    throw new NekoError('AvatarError', 'El radio debe ser positivo y caber dentro de la imagen');
+                }
                 this.data.avatar.radio = data.radio;
             }
         }
@@ -464,8 +468,8 @@ class Welcome {
 
         try {
             const [bg, avatar] = await Promise.all([
-                this.data.background.type == 'image' ? Canvas.loadImage(this.data.background.value) : null,
-                Canvas.loadImage(this.data.avatar.source)
+                this.data.background.type == 'image' ? loadImageSource(this.data.background.value, 'el fondo') : null,
+                loadImageSource(this.data.avatar.source, 'el avatar')
             ])
 
             const canvas = Canvas.createCanvas(this.data.width, this.data.height)
@@ -481,35 +485,43 @@ class Welcome {
                 ctx.fillRect(0, 0, canvas.width, canvas.height);
             }
 
-            const maxTitleWidth = this.data.width * 0.8;
-            let titleFontSize = this.data.title.font_size;
-            ctx.font = `${titleFontSize}px ${this.data.font}`;
+            const maxTitleWidth = this.data.width * 0.8;
+            let titleFontSize = this.data.layout === 'center'
+                ? Math.min(this.data.title.font_size, this.data.height * 0.14)
+                : this.data.title.font_size;
+            ctx.font = `${titleFontSize}px ${this.data.font}`;
 
             while (ctx.measureText(this.data.title.content).width > maxTitleWidth && titleFontSize > 10) {
                 titleFontSize -= 1;
                 ctx.font = `${titleFontSize}px ${this.data.font}`;
             }
 
-            ctx.fillStyle = this.data.title.text_color;
-            ctx.textAlign = "center";
-            ctx.fillText(this.data.title.content, this.data.title.x, this.data.title.y);
-
-            const maxDescWidth = this.data.width * 0.9;
-            let descFontSize = this.data.description.font_size;
-            ctx.font = `${descFontSize}px ${this.data.font}`;
+            const maxDescWidth = this.data.width * 0.9;
+            let descFontSize = this.data.layout === 'center'
+                ? Math.min(this.data.description.font_size, this.data.height * 0.09)
+                : this.data.description.font_size;
+            ctx.font = `${descFontSize}px ${this.data.font}`;
 
             while (ctx.measureText(this.data.description.content).width > maxDescWidth && descFontSize > 8) {
                 descFontSize -= 1;
                 ctx.font = `${descFontSize}px ${this.data.font}`;
             }
 
-            ctx.fillStyle = this.data.description.text_color;
-            ctx.textAlign = "center";
-            ctx.fillText(this.data.description.content, this.data.description.x, this.data.description.y);
-
-            const x = this.data.avatar.x;
-            const y = this.data.avatar.y;
-            const radio = this.data.avatar.radio;
+            const layout = this.data.layout === 'center'
+                ? calculateCenteredLayout(this.data, titleFontSize, descFontSize)
+                : {
+                    avatarX: this.data.avatar.x,
+                    avatarY: this.data.avatar.y,
+                    radio: this.data.avatar.radio,
+                    titleX: this.data.title.x,
+                    titleY: this.data.title.y,
+                    descriptionX: this.data.description.x,
+                    descriptionY: this.data.description.y
+                };
+
+            const x = layout.avatarX;
+            const y = layout.avatarY;
+            const radio = layout.radio;
 
             if (this.data.avatar.border) {
                 ctx.beginPath();
@@ -524,8 +536,18 @@ class Welcome {
             ctx.arc(x + radio, y + radio, radio, 0, Math.PI * 2, true);
             ctx.closePath();
             ctx.clip();
-            ctx.drawImage(avatar, x, y, radio * 2, radio * 2);
-            ctx.restore();
+            ctx.drawImage(avatar, x, y, radio * 2, radio * 2);
+            ctx.restore();
+
+            ctx.textAlign = 'center';
+            ctx.textBaseline = this.data.layout === 'center' ? 'middle' : 'alphabetic';
+            ctx.font = `${titleFontSize}px ${this.data.font}`;
+            ctx.fillStyle = this.data.title.text_color;
+            ctx.fillText(this.data.title.content, layout.titleX, layout.titleY);
+
+            ctx.font = `${descFontSize}px ${this.data.font}`;
+            ctx.fillStyle = this.data.description.text_color;
+            ctx.fillText(this.data.description.content, layout.descriptionX, layout.descriptionY);
 
             return canvas.toBuffer();
         } catch (error) {
@@ -535,6 +557,50 @@ class Welcome {
             throw new NekoError('GenerateError', 'Error al generar la imagen: '+error.message)
         }
     }
-}
-
-module.exports = Welcome;
+}
+
+function calculateCenteredLayout(data, titleFontSize, descFontSize) {
+    const borderSize = data.avatar.border ? 6 : 0;
+    const avatarGap = clamp(data.height * 0.045, 16, 32);
+    const textGap = clamp(data.height * 0.018, 8, 16);
+    const availableHeight = data.height * 0.9;
+    const maxRadio = Math.max(
+        16,
+        (availableHeight - titleFontSize - descFontSize - avatarGap - textGap) / 2 - borderSize
+    );
+    const radio = Math.min(data.avatar.radio, maxRadio);
+    const avatarOuterSize = (radio + borderSize) * 2;
+    const contentHeight = avatarOuterSize + avatarGap + titleFontSize + textGap + descFontSize;
+    const startY = (data.height - contentHeight) / 2;
+    const centerX = data.width / 2;
+    const avatarX = centerX - radio;
+    const avatarY = startY + borderSize;
+    const titleY = startY + avatarOuterSize + avatarGap + titleFontSize / 2;
+    const descriptionY = titleY + titleFontSize / 2 + textGap + descFontSize / 2;
+
+    return {
+        avatarX,
+        avatarY,
+        radio,
+        titleX: centerX,
+        titleY,
+        descriptionX: centerX,
+        descriptionY
+    };
+}
+
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+
+function validateDimension(value, name) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || !Number.isFinite(value)) {
+        throw new NekoError('TypeError', `el parametro <${name}> debe ser un número entero`);
+    }
+    if (value < MIN_DIMENSION || value > MAX_DIMENSION) {
+        throw new NekoError('ResolutionError', `<${name}> debe estar entre ${MIN_DIMENSION} y ${MAX_DIMENSION} píxeles`);
+    }
+    return value;
+}
+
+module.exports = Welcome;

package/sources/classes/user/BaseUser.js

@@ -1,6 +1,7 @@
 'use strict';
 
-let tokenGlobal = null;
+let tokenGlobal = null;
+let tokenVersion = 0;
 
 /**
  * Clase BaseUser
@@ -11,17 +12,30 @@ class BaseUser {
      * Establece el token "global" en todo el paquete.
      * @param {string} token token a establecer.
      */
-    static setToken(token) {
-        tokenGlobal = token;
+    static setToken(token) {
+        if (typeof token !== 'string' || !token.trim()) {
+            throw new TypeError('El token debe ser una cadena no vacía');
+        }
+        const normalizedToken = token.trim();
+        if (tokenGlobal !== normalizedToken) tokenVersion += 1;
+        tokenGlobal = normalizedToken;
     }
 
     /**
      * Obten el token del usuario si este ya se estableció
      * @returns {string} Token de usuario
      */
-    static getToken() {
-        return tokenGlobal;
-    }
-}
+    static getToken() {
+        return tokenGlobal;
+    }
+
+    /**
+     * Identificador interno que cambia cada vez que se establece otro token.
+     * @returns {number}
+     */
+    static getTokenVersion() {
+        return tokenVersion;
+    }
+}
 
 module.exports = BaseUser;

package/sources/classes/user/User.js

@@ -12,9 +12,9 @@ class User {
      * Puedes establecer el token aqui, sin embargo, recomiendo hacerlo en el metodo dedicado
      * @param {string} token Token de la api 
      */
-    constructor(token) {
-        this.token_ = token
-        setToken(this.#getToken());
+    constructor(token) {
+        this.token_ = undefined;
+        if (token !== undefined) this.token(token);
     }
 
     /**
@@ -23,9 +23,9 @@ class User {
      * @throws {NekoError} si el token no fue dado o no es una cadena
      */
     token(token) {
-        if(!token) throw new NekoError('NoToken', 'el parametro <token> es requerido');
-        if(typeof(token) !== 'string') throw new NekoError('InvalidType', `Token invaldo... el tipo de dato es String no ${typeof(token)}`);
-        this.token_ = token;
+        if(typeof(token) !== 'string') throw new NekoError('InvalidType', `El token debe ser string, no ${typeof(token)}`);
+        if(!token.trim()) throw new NekoError('NoToken', 'el parametro <token> es requerido');
+        this.token_ = token.trim();
         setToken(this.#getToken());
     }
 
@@ -38,4 +38,4 @@ class User {
     }
 }
 
-module.exports = User
+module.exports = User

package/sources/main/index.js

@@ -8,7 +8,7 @@ exports.User = require('../classes/user/User.js')
 
 exports.NekoGif = require('../classes/package/NekoGif.js')
 exports.BaseUser = require('../classes/user/BaseUser.js')
-exports.Welcome = require('../classes/package/Welcome.js')
+exports.Welcome = require('../classes/package/welcome.js')
 
 // rest
 
@@ -16,9 +16,11 @@ exports.APIClient = require('../rest/APIClient.js')
 
 // errores
 
-exports.APIError = require('../classes/errors/APIerror.js')
-exports.Error = require('../classes/errors/Error.js')
+exports.APIError = require('../classes/errors/APIError.js')
+exports.NekoError = require('../classes/errors/Error.js')
+// Alias conservado por compatibilidad con versiones 2.0.x.
+exports.Error = exports.NekoError
 
 //#region "constantes"
 
-exports.SFW = require('../classes/SFW.js')
+exports.SFW = require('../classes/SFW.js')

package/sources/rest/APIClient.js

@@ -5,9 +5,10 @@
  * @typedef {import('../typings').GifResponse} GifResponse
  */
 
-const APIError = require('../classes/errors/APIerror.js');
-
-const fetch = import('node-fetch');
+const APIError = require('../classes/errors/APIError.js');
+const NekoError = require('../classes/errors/Error.js');
+
+const DEFAULT_TIMEOUT_MS = 10_000;
 
 /**
  * Clase APIClient
@@ -19,12 +20,28 @@ class APIClient {
      * @param {string} baseURL link principal de la api
      * @param {APIClientData} data objeto para las solicitudes
      */
-    constructor(baseURL, data) {
+    constructor(baseURL, data) {
+        if (typeof baseURL !== 'string' || !baseURL) {
+            throw new NekoError('InvalidBaseURL', 'El parámetro <baseURL> debe ser una URL válida');
+        }
+
+        let parsedBaseURL;
+        try {
+            parsedBaseURL = new URL(baseURL);
+        } catch {
+            throw new NekoError('InvalidBaseURL', 'El parámetro <baseURL> debe ser una URL válida');
+        }
+        if (parsedBaseURL.protocol !== 'https:') {
+            throw new NekoError('InvalidBaseURL', 'La API debe utilizar HTTPS');
+        }
+        if (!data || typeof data.token !== 'string' || !data.token.trim()) {
+            throw new NekoError('NoToken', 'Se requiere un token para utilizar la API');
+        }
         /**
          * url principal
          * @type {string}
          */
-        this.baseURL = baseURL
+        this.baseURL = baseURL.replace(/\/$/, '')
         /**
          * data
          * @type {APIClientData}
@@ -34,32 +51,57 @@ class APIClient {
     /**
      * Obtiene el objeto compartido por la api a traves de la ruta y con autorizacion por token
      * @param {string} endpoint establece la ruta a la que se quiere comunicar
-     * @returns {Promise<GifResponse>}
+     * @template {import('../typings').ApiResponse} [T=GifResponse]
+     * @returns {Promise<T>}
      * @throws {APIError} solo si sucede un error entre solicitudes
      */
-    async get(endpoint) {
-        try {
-            const response = await (await fetch).default(`${this.baseURL}${endpoint}`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': `${this.data.token}`,
-                    'Content-Type': 'application/json'
-                }
-            });
-
-            if (!response.ok) {
-                throw new APIError(endpoint, response, await response.json());
-            }
-
-            return response.json()
-        } catch (error) {
-            if (error instanceof APIError) {
-                throw error;
-            } else {
-                throw new APIError(endpoint, { message: error.message }, {});
-            }
-        }
-    }
-}
+    async get(endpoint, options = {}) {
+        if (typeof endpoint !== 'string' || !endpoint.startsWith('/')) {
+            throw new NekoError('InvalidEndpoint', 'El endpoint debe comenzar con "/"');
+        }
+
+        const timeout = Number.isFinite(options.timeout) && options.timeout > 0
+            ? options.timeout
+            : DEFAULT_TIMEOUT_MS;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        try {
+            const response = await fetch(`${this.baseURL}${endpoint}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `${this.data.token}`,
+                    'Content-Type': 'application/json'
+                },
+                signal: controller.signal
+            });
+
+            const data = await readJson(response);
+            if (!response.ok) {
+                throw new APIError(endpoint, response, data);
+            }
+
+            return /** @type {T} */ (data)
+        } catch (error) {
+            if (error instanceof APIError) {
+                throw error;
+            }
+            const message = error?.name === 'AbortError'
+                ? `La solicitud excedió el tiempo límite de ${timeout} ms`
+                : error?.message ?? 'No fue posible conectar con la API';
+            throw APIError.fromNetworkError(endpoint, `${this.baseURL}${endpoint}`, message);
+        } finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+
+async function readJson(response) {
+    try {
+        return await response.json();
+    } catch {
+        return { code: response.status, message: 'La API devolvió una respuesta que no es JSON' };
+    }
+}
 
-module.exports = APIClient;
+module.exports = APIClient;