neekuro 2.0.4 → 2.1.0

package/README.md

@@ -83,13 +83,47 @@ const welcome = new Welcome()
   .setDescription('Al servidor de Discord');
 
 // Genera y guarda la imagen
-welcome.build()
+welcome.build()
   .then(image => fs.writeFileSync('bienvenida.png', image))
   .then(() => console.log('Imagen creada correctamente!'))
   .catch(err => console.error('Error:', err.message));
 
 // nota: como antes, todo viene bien documentado en el paquete, solo sigue los pasos y explora por ti ;3
-```
+```
+
+Las imágenes remotas deben usar HTTPS. El paquete limita cada descarga a 10 MB,
+aplica un tiempo máximo de 10 segundos, comprueba el formato y bloquea direcciones
+locales o privadas. También puedes proporcionar un `Buffer` JPEG, PNG, GIF o WebP.
+
+La resolución admite valores enteros entre 128 y 4096 píxeles. Para regresar al
+tamaño original de 1140 × 520 puedes usar:
+
+```javascript
+welcome.setResolution('default', 'default');
+```
+
+Por defecto, el avatar, el título y la descripción forman una columna centrada
+horizontal y verticalmente. El tamaño del avatar y de los textos se adapta cuando
+la resolución es pequeña. Si necesitas coordenadas personalizadas puedes activar
+el modo manual directamente o proporcionar `x`/`y` en cualquiera de los elementos:
+
+```javascript
+welcome.setLayout('manual');
+
+// Para regresar a la distribución automática:
+welcome.setLayout('center');
+```
+
+## Desarrollo
+
+```sh
+pnpm install
+pnpm run check
+pnpm run pack:check
+```
+
+`pnpm run check` ejecuta las pruebas funcionales locales y comprueba las
+declaraciones TypeScript. Ninguna de estas pruebas consulta la API remota.
 <hr>
 <center>
 <p>Resultado esperado</p>

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "neekuro",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Una biblioteca de imágenes con temática de anime para bots de Discord.",
   "main": "sources/main/index.js",
   "types": "sources/typings/index.d.ts",
@@ -25,9 +25,9 @@
     "README.md"
   ],
   "contributors": [
-    "cacao0027 <kzmkuro@gmail.com>"
+    "cacao0027 <kmzkuro@gmail.com>"
   ],
-  "author": "cacao0027 <kzmkuro@gmail.com>",
+  "author": "cacao0027 <kmzkuro@gmail.com>",
   "keywords": [
     "anime",
     "acción",
@@ -40,17 +40,22 @@
     "images"
   ],
   "license": "ISC",
+  "packageManager": "pnpm@11.23.0",
   "scripts": {
-    "test": "nodemon node ./test/main.test.js"
+    "test": "node --test test/*.test.js",
+    "check": "node --check sources/main/index.js && node --test test/*.test.js && tsc -p test/tsconfig.json",
+    "pack:check": "npm pack --dry-run"
   },
   "engines": {
     "node": ">=20.12.2"
   },
   "dependencies": {
     "canvas": "^3.1.0",
-    "hex-color-regex": "^1.1.0",
-    "neekuro": "file:",
-    "node-fetch": "^3.3.2"
+    "hex-color-regex": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
   },
   "repository": {
     "type": "git",

package/sources/classes/SFW.js

@@ -23,11 +23,13 @@ class SFW {
      * @param {GifMap[T]} gif corresponde al gif que quieras obtener por categoria
      * @returns {Promise<NekoGif>}
      */
-    static async getGif(cat, gif) {
+    static async getGif(cat, gif) {
         if (!cat) throw new NekoError('NoInput', 'el parametro <cat> es requerido');
         if (!gif) throw new NekoError('NoInput', 'el parametro <gif> es requerido');
 
-        let solicitud = new APIClient(base, { token: getToken() }), response = null;
+        const token = getToken();
+        if (!token) throw new NekoError('NoToken', 'Debes establecer un token antes de solicitar un GIF');
+        let solicitud = new APIClient(base, { token }), response = null;
         switch (cat) {
             case 'action':
                 response = solicitud.get('/action/' + gif + '?random=true')
@@ -42,4 +44,4 @@ class SFW {
     }
 }
 
-module.exports = SFW
+module.exports = SFW

package/sources/classes/errors/{APIerror.js → APIError.js}

@@ -2,7 +2,7 @@
 
 /**
  * @typedef {import('../../typings').ApiResponse} ApiResponse
- * @typedef {import('node-fetch').Response} Response
+ * @typedef {{url?: string, status?: number}} ResponseLike
  */
 
 /**
@@ -14,15 +14,13 @@ class APIError extends Error {
     /**
      * Crea la instancia del error
      * @param {string} endpoint la ruta a la que se realizo la peticion
-     * @param {Response} response respuesta de node-fetch
+     * @param {ResponseLike} response respuesta HTTP o representación de un error de red
      * @param {ApiResponse} data respuesta de la api
      */
-    constructor(endpoint, response, data) {
-        super();
+    constructor(endpoint, response, data) {
+        super(APIError.determineMessage(data));
         
         this.name = `NekoREST Error [${endpoint}]`
-        this.message = this.#determineMessage(data);
-
         /**
          * @type {string}
          */
@@ -31,7 +29,7 @@ class APIError extends Error {
         /**
          * @type {number}
          */
-        this.statusCode = parseInt(response?.status ?? 500);
+        this.statusCode = Number.parseInt(response?.status ?? 500, 10);
 
         /**
          * @type {ApiResponse}
@@ -45,7 +43,7 @@ class APIError extends Error {
      * @param {ApiResponse} response respuesta de la api
      * @returns {string} mensaje de error
      */
-    #determineMessage(response) {
+    static determineMessage(response = {}) {
         if(response.code === 403) {
             return 'TOKEN ERROR: el token que haz proporcionado es invalido'
         } else 
@@ -54,7 +52,11 @@ class APIError extends Error {
         } else {
             return response.message ?? 'descripcion no dada'
         }
-    }
-}
-
-module.exports = APIError
+    }
+
+    static fromNetworkError(endpoint, url, message) {
+        return new APIError(endpoint, { url, status: 503 }, { code: 503, message });
+    }
+}
+
+module.exports = APIError

package/sources/classes/errors/Error.js

@@ -10,16 +10,17 @@ class NekoError extends Error {
      * @param {string} name Corresponde al nombre del error
      * @param {string} message Mensaje de error
      */
-    constructor(name, message) {
-        super(message);
+    constructor(name, message) {
+        super(message);
         
         this.name = `NeeKuro Error [${name}]`
         
         /**
          * @type {string}
          */
-        this.message = message
+        this.message = message
+        Error.captureStackTrace?.(this, NekoError);
     }
 }
 
-module.exports = NekoError
+module.exports = NekoError

package/sources/classes/package/NekoGif.js

@@ -14,19 +14,22 @@ class NekoGif {
      * Recibe la respuesta de la api
      * @param {GifResponse} response respuesta de la api 
      */
-    constructor(response) {
+    constructor(response) {
+        if (!response || typeof response !== 'object' || !response.data) {
+            throw new TypeError('La respuesta no contiene datos de imagen');
+        }
         
         /**
          * URL del gif
          * @type {string|null}
          */
-        this.url = response.data.url || null
+        this.url = typeof response.data.url === 'string' ? response.data.url : null
         
         /**
          * Anime del gif
          * @type {string|null}
          */
-        this.anime = response.data.anime || null
+        this.anime = typeof response.data.anime === 'string' ? response.data.anime : null
     }
 
     /**
@@ -47,4 +50,4 @@ class NekoGif {
 
 }
 
-module.exports = NekoGif
+module.exports = NekoGif

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

@@ -11,8 +11,11 @@ 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');
+        }
+        tokenGlobal = token;
     }
 
     /**

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}
@@ -37,29 +54,53 @@ class APIClient {
      * @returns {Promise<GifResponse>}
      * @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 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;

package/sources/typings/index.d.ts

@@ -1,6 +1,4 @@
-import { Response } from "node-fetch";
-
-//#region constants
+//#region constants
 
 /**
  * Categoria SFW
@@ -109,8 +107,9 @@ export interface WelcomeTextData {
     text_color?: string
 }
 
-export interface WelcomeData {
-    font: FontNames;
+export interface WelcomeData {
+    font: FontNames;
+    layout: 'center' | 'manual';
     width: number;
     height: number;
     background: WelcomeBackgroundData;
@@ -147,8 +146,8 @@ export declare interface GifMap {
     reaction: ReactionGifs
 }
 
-export interface GifResponse extends ApiResponse {
-    data?: {
+export interface GifResponse extends ApiResponse {
+    data: {
         url: string;
         anime: string;
     }
@@ -187,7 +186,10 @@ export class Welcome {
      * @param height Alto en píxeles o 'default' para 450px
      * @throws {NekoError} Si los parámetros son inválidos
      */
-    setResolution(width: number | 'default', height: number | 'default'): this;
+    setResolution(width: number | 'default', height: number | 'default'): this;
+
+    /** Selecciona distribución automática centrada o coordenadas manuales. */
+    setLayout(layout: 'center' | 'manual'): this;
 
     /**
      * Configura la tipografía para el texto de la imagen
@@ -253,7 +255,7 @@ export class User {
      * puedes establecer el token a partir de aqui, pero recomiendo usar el metodo dedicado
      * @param token Token de la api
      */
-    constructor(token: string);
+    constructor(token?: string);
     /**
      * establece el token para usar la api
      * @example 
@@ -314,7 +316,7 @@ export class BaseUser {
  * Clase APIClient
  * Se encarga de hacer las solicitudes al servidor
  */
-export class APIClient {
+export class APIClient {
     /**
      * Instanciamiento de la clase
      * @param baseUrl baseUrl: link principal de la api
@@ -328,7 +330,7 @@ export class APIClient {
      * @param endpoint establece la ruta a la que se quiere comunicar en la api
      * @throws {APIError} solo si sucede un error entre solicitudes
      */
-    public get(endpoint: string): Promise<GifResponse>
+    public get(endpoint: string, options?: { timeout?: number }): Promise<GifResponse>
 }
 
 /**
@@ -362,23 +364,26 @@ export class APIError extends Error {
     /**
      * Instanciamiento de un error de api 
      * @param endpoint endpoint: ruta solicitada
-     * @param response response: respuesta por node-fetch
+     * @param response respuesta HTTP o representación de un error de red
      * @param data data: objeto dado por la api
      */
-    constructor(endpoint: string, response: Awaited<Response>, data: ApiResponse);
+    constructor(endpoint: string, response: { url?: string; status?: number }, data: ApiResponse);
 }
 
 /**
  * Clase NekoError
  * Errores personalizados respecto al paquete
  */
-export class NekoError extends Error {
+export class NekoError extends Error {
     /**
      * Instanciamiento de un error del paquete
      * @param name name: nombre del error
      * @param message message: mensaje del error
      */
     constructor(name: string, message: string);
-}
+}
+
+/** Alias heredado de versiones 2.0.x. Prefiere NekoError. */
+export { NekoError as Error };
 
-//#endregion
+//#endregion

package/sources/utils/imageLoader.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const dns = require('node:dns').promises;
+const net = require('node:net');
+const Canvas = require('canvas');
+const NekoError = require('../classes/errors/Error.js');
+
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const IMAGE_TIMEOUT_MS = 10_000;
+const MAX_REDIRECTS = 3;
+const IMAGE_CONTENT_TYPES = new Set(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
+
+async function loadImageSource(source, label = 'imagen') {
+    if (Buffer.isBuffer(source)) {
+        validateImageBuffer(source, label);
+        return Canvas.loadImage(source);
+    }
+    return Canvas.loadImage(await downloadImage(source, label));
+}
+
+async function downloadImage(source, label = 'imagen') {
+    let currentURL = parseRemoteURL(source, label);
+
+    for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects += 1) {
+        await assertPublicHostname(currentURL.hostname, label);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), IMAGE_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(currentURL, {
+                redirect: 'manual',
+                signal: controller.signal,
+                headers: { 'User-Agent': 'neekuro/2.1 image-loader' }
+            });
+        } catch (error) {
+            const message = error?.name === 'AbortError'
+                ? `La descarga de ${label} excedió ${IMAGE_TIMEOUT_MS} ms`
+                : `No se pudo descargar ${label}: ${error?.message ?? 'error desconocido'}`;
+            throw new NekoError('ImageDownloadError', message);
+        } finally {
+            clearTimeout(timeoutId);
+        }
+
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get('location');
+            if (!location || redirects === MAX_REDIRECTS) {
+                throw new NekoError('ImageDownloadError', `Demasiadas redirecciones al descargar ${label}`);
+            }
+            currentURL = parseRemoteURL(new URL(location, currentURL).href, label);
+            continue;
+        }
+        if (!response.ok) {
+            throw new NekoError('ImageDownloadError', `No se pudo descargar ${label}: HTTP ${response.status}`);
+        }
+
+        const contentType = response.headers.get('content-type')?.split(';', 1)[0].toLowerCase();
+        if (!contentType || !IMAGE_CONTENT_TYPES.has(contentType)) {
+            throw new NekoError('ImageFormatError', `${label} no tiene un formato de imagen compatible`);
+        }
+        const declaredLength = Number(response.headers.get('content-length'));
+        if (Number.isFinite(declaredLength) && declaredLength > MAX_IMAGE_BYTES) {
+            throw new NekoError('ImageSizeError', `${label} supera el límite de 10 MB`);
+        }
+        return readLimitedBody(response, label);
+    }
+    throw new NekoError('ImageDownloadError', `No se pudo descargar ${label}`);
+}
+
+function parseRemoteURL(source, label) {
+    if (typeof source !== 'string') {
+        throw new NekoError('ImageURLerror', `${label} debe ser una URL HTTPS o un Buffer`);
+    }
+    let url;
+    try {
+        url = new URL(source);
+    } catch {
+        throw new NekoError('ImageURLerror', `La URL de ${label} no es válida`);
+    }
+    if (url.protocol !== 'https:' || url.username || url.password) {
+        throw new NekoError('ImageURLerror', `La URL de ${label} debe utilizar HTTPS y no incluir credenciales`);
+    }
+    return url;
+}
+
+async function assertPublicHostname(hostname, label) {
+    const normalized = hostname.toLowerCase().replace(/\.$/, '');
+    if (normalized === 'localhost' || normalized.endsWith('.localhost') || normalized.endsWith('.local')) {
+        throw new NekoError('ImageURLerror', `La URL de ${label} apunta a una red local`);
+    }
+    const addresses = net.isIP(normalized)
+        ? [{ address: normalized }]
+        : await dns.lookup(normalized, { all: true, verbatim: true }).catch(() => []);
+    if (!addresses.length || addresses.some(({ address }) => isPrivateAddress(address))) {
+        throw new NekoError('ImageURLerror', `La URL de ${label} no apunta a una dirección pública`);
+    }
+}
+
+function isPrivateAddress(address) {
+    if (net.isIPv4(address)) {
+        const [a, b] = address.split('.').map(Number);
+        return a === 0 || a === 10 || a === 127 ||
+            (a === 100 && b >= 64 && b <= 127) || (a === 169 && b === 254) ||
+            (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) ||
+            (a === 198 && (b === 18 || b === 19)) || a >= 224;
+    }
+    if (net.isIPv6(address)) {
+        const value = address.toLowerCase();
+        return value === '::' || value === '::1' || value.startsWith('fc') || value.startsWith('fd') ||
+            /^fe[89ab]/.test(value) || value.startsWith('ff') || value.startsWith('2001:db8:') ||
+            (value.startsWith('::ffff:') && isPrivateAddress(value.slice(7)));
+    }
+    return true;
+}
+
+async function readLimitedBody(response, label) {
+    if (!response.body) throw new NekoError('ImageDownloadError', `${label} no contiene datos`);
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of response.body) {
+        const buffer = Buffer.from(chunk);
+        size += buffer.length;
+        if (size > MAX_IMAGE_BYTES) {
+            await response.body.cancel().catch(() => undefined);
+            throw new NekoError('ImageSizeError', `${label} supera el límite de 10 MB`);
+        }
+        chunks.push(buffer);
+    }
+    const result = Buffer.concat(chunks);
+    validateImageBuffer(result, label);
+    return result;
+}
+
+function validateImageBuffer(buffer, label = 'imagen') {
+    if (!Buffer.isBuffer(buffer) || buffer.length < 12) {
+        throw new NekoError('ImageFormatError', `${label} no contiene una imagen válida`);
+    }
+    if (buffer.length > MAX_IMAGE_BYTES) {
+        throw new NekoError('ImageSizeError', `${label} supera el límite de 10 MB`);
+    }
+    const header = buffer.subarray(0, 12).toString('hex');
+    const valid = header.startsWith('ffd8ff') || header.startsWith('89504e470d0a1a0a') ||
+        header.startsWith('47494638') || (header.slice(0, 8) === '52494646' && header.slice(16, 24) === '57454250');
+    if (!valid) throw new NekoError('ImageFormatError', `${label} debe ser JPEG, PNG, GIF o WebP`);
+}
+
+module.exports = { IMAGE_TIMEOUT_MS, MAX_IMAGE_BYTES, isPrivateAddress, loadImageSource, parseRemoteURL, validateImageBuffer };