stelar-time-real 2.0.2 → 2.0.4

package/README.md

@@ -1,37 +1,37 @@
 # stelar-time-real
 
-Tu propio sistema de tiempo real personalizado. Una librería ligera y sin dependencias para comunicación en tiempo real via WebSockets.
+Your own custom real-time system. A lightweight, dependency-free library for real-time communication via WebSockets.
 
 ![npm](https://img.shields.io/npm/v/stelar-time-real)
 ![license](https://img.shields.io/npm/l/stelar-time-real)
 ![size](https://img.shields.io/bundlephobia/min/stelar-time-real)
 
-## ¿Por qué stelar-time-real?
+## Why stelar-time-real?
 
-- ⚡ **Ultra ligera** - Solo ~13MB de heap
-- 🚀 **Sin dependencias** - Usa solo `ws` (WebSocket nativo)
-- 🎯 **Personalizable** - Vos controlás todo, nada de código ajeno
-- 🔌 **Compatible** - Funciona con Express, Fastify, HTTP nativo, etc.
-- 💓 **Heartbeat incluido** - Detecta desconexiones automáticamente
-- 🌐 **Namespaces** - Múltiples canales independientes (`/chat`, `/game`, etc.)
-- ⚡ **ACK ultra rápido** - Request-response con Promesas, sin overhead
-- 📦 **Binarios** - Envía imágenes, archivos, audio, video sin overhead de base64
+- ⚡ **Ultra lightweight** - Only ~13MB of heap
+- 🚀 **No dependencies** - Uses only native `ws` (WebSocket)
+- 🎯 **Fully customizable** - You control everything, no one else's code
+- 🔌 **Compatible** - Works with Express, Fastify, native HTTP, etc.
+- 💓 **Heartbeat included** - Automatically detects disconnections
+- 🌐 **Namespaces** - Multiple independent channels (`/chat`, `/game`, etc.)
+- ⚡ **Ultra fast ACK** - Request-response with Promises, no overhead
+- 📦 **Binaries** - Send images, files, audio, video without base64 overhead
 
-## Instalación
+## Installation
 
 ```bash
 npm install stelar-time-real
 ```
 
-## Inicio Rápido
+## Quick Start
 
-### Un solo import para todo
+### One import for everything
 
 ```javascript
 import StelarServer, { StelarClient } from 'stelar-time-real';
 ```
 
-### Servidor
+### Server
 
 ```javascript
 import express from 'express';
@@ -43,18 +43,18 @@ const server = app.listen(3000);
 const stelar = new StelarServer({ server });
 
 stelar.onConnection((client) => {
-  console.log('Nuevo cliente:', client.id);
-  client.emit('bienvenida', '¡Hola! Bienvenido a stelar-time-real');
+  console.log('New client:', client.id);
+  client.emit('welcome', 'Hello! Welcome to stelar-time-real');
 });
 
-stelar.on('mensaje', (ctx) => {
-  ctx.broadcast('mensaje', ctx.data);
+stelar.on('message', (ctx) => {
+  ctx.broadcast('message', ctx.data);
 });
 
 stelar.start();
 ```
 
-### Cliente
+### Client
 
 ```javascript
 import { StelarClient } from 'stelar-time-real';
@@ -62,19 +62,19 @@ import { StelarClient } from 'stelar-time-real';
 const client = new StelarClient('localhost:3000');
 
 client.on('connect', () => {
-  console.log('Conectado!');
+  console.log('Connected!');
 });
 
-client.on('bienvenida', (msg) => {
+client.on('welcome', (msg) => {
   console.log(msg);
 });
 
 client.connect();
 ```
 
-## API Completa
+## Full API
 
-### StelarServer (Lado del Servidor)
+### StelarServer (Server Side)
 
 #### Constructor
 
@@ -82,21 +82,21 @@ client.connect();
 new StelarServer({ server, port, heartbeatInterval })
 ```
 
-| Opción | Tipo | Default | Descripción |
+| Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| server | http.Server | null | Tu server HTTP existente |
-| port | number | 3000 | Puerto si no pasás server |
-| heartbeatInterval | number | 30000 | Intervalo de ping en ms |
+| server | http.Server | null | Your existing HTTP server |
+| port | number | 3000 | Port if you don't pass server |
+| heartbeatInterval | number | 30000 | Ping interval in ms |
 
-#### Métodos
+#### Methods
 
 **`.use(middleware)`**
-Agregar middleware para validar conexiones.
+Add middleware to validate connections.
 
 ```javascript
 stelar.use((ctx, next) => {
   const token = ctx.req.headers['x-token'];
-  if (token === 'secreto') {
+  if (token === 'secret') {
     next();
   } else {
     ctx.socket.close();
@@ -105,125 +105,125 @@ stelar.use((ctx, next) => {
 ```
 
 **`.on(event, handler)`**
-Escuchar eventos del cliente.
+Listen for client events.
 
 ```javascript
 stelar.on('chat', (ctx) => {
-  console.log('Mensaje:', ctx.data);
+  console.log('Message:', ctx.data);
   ctx.broadcast('chat', ctx.data);
 });
 ```
 
 **`.onAll(handler)`**
-Escuchar todos los eventos (útil para debug).
+Listen for all events (useful for debug).
 
 ```javascript
 stelar.onAll(({ event, data }) => {
-  console.log(`Evento: ${event}`, data);
+  console.log(`Event: ${event}`, data);
 });
 ```
 
 **`.onConnection(handler)`**
-Ejecutar cuando un cliente se conecta.
+Execute when a client connects.
 
 ```javascript
 stelar.onConnection((client) => {
-  client.emit('bienvenida', 'Hola!');
+  client.emit('welcome', 'Hello!');
 });
 ```
 
 **`.broadcast(event, data)`**
-Enviar a todos los clientes.
+Send to all clients.
 
 ```javascript
-stelar.broadcast('chat', { mensaje: 'Hola a todos' });
+stelar.broadcast('chat', { message: 'Hello everyone' });
 ```
 
 **`.to(room, event, data)`**
-Enviar a una sala específica.
+Send to a specific room.
 
 ```javascript
-stelar.to('sala-1', 'chat', { mensaje: 'Hola sala 1' });
+stelar.to('room-1', 'chat', { message: 'Hello room 1' });
 ```
 
 **`.toId(id, event, data)`**
-Enviar a un cliente específico por ID.
+Send to a specific client by ID.
 
 ```javascript
-stelar.toId('abc123', 'privado', 'Solo para ti');
+stelar.toId('abc123', 'private', 'Just for you');
 ```
 
 **`.getClients(room)`**
-Obtener lista de clientes.
+Get list of clients.
 
 ```javascript
-const todos = stelar.getClients();
-const sala = stelar.getClients('mi-sala');
+const all = stelar.getClients();
+const room = stelar.getClients('my-room');
 ```
 
 **`.getPort()`**
-Obtener el puerto donde está corriendo.
+Get the port where it's running.
 
 ```javascript
-console.log('Puerto:', stelar.getPort());
+console.log('Port:', stelar.getPort());
 ```
 
 **`.start(callback)`**
-Iniciar el servidor WebSocket.
+Start the WebSocket server.
 
 ```javascript
 await stelar.start();
-console.log('Iniciado!');
+console.log('Started!');
 ```
 
 **`.stop()`**
-Detener el servidor.
+Stop the server.
 
 ```javascript
 stelar.stop();
 ```
 
-#### Contexto (ctx) en handlers
+#### Context (ctx) in handlers
 
-Cuando escuchás un evento, recibís un `ctx` con:
+When you listen to an event, you receive a `ctx` with:
 
 ```javascript
-stelar.on('mensaje', (ctx) => {
-  ctx.id          // ID único del cliente
-  ctx.socket      // WebSocket del cliente
-  ctx.req         // Request HTTP original
-  ctx.data        // Datos recibidos
+stelar.on('message', (ctx) => {
+  ctx.id          // Unique client ID
+  ctx.socket      // Client's WebSocket
+  ctx.req         // Original HTTP request
+  ctx.data        // Received data
 
-  // Métodos disponibles:
-  ctx.emit('evento', data)     // Enviar solo a este cliente
-  ctx.send('respuesta', data)  // Responder a un ACK
-  ctx.broadcast('evento', data) // Enviar a todos
-  ctx.to('sala', 'evento', data) // Enviar a una sala
-  ctx.toId('id', 'evento', data) // Enviar a un cliente específico
-  ctx.getClients('sala')      // Ver clientes en sala
-  ctx.joinRoom('sala')        // Unir a sala
-  ctx.leaveRoom()             // Salir de sala
-  ctx.ack('miAck', data)     // Responder a un ACK personalizado
+  // Available methods:
+  ctx.emit('event', data)     // Send to this client only
+  ctx.send('response', data)  // Reply to an ACK
+  ctx.broadcast('event', data) // Send to everyone
+  ctx.to('room', 'event', data) // Send to a room
+  ctx.toId('id', 'event', data) // Send to specific client
+  ctx.getClients('room')      // See clients in room
+  ctx.joinRoom('room')        // Join room
+  ctx.leaveRoom()             // Leave room
+  ctx.ack('myAck', data)     // Reply to a custom ACK
 });
 ```
 
 #### Namespaces
 
-Crear canales independientes:
+Create independent channels:
 
 ```javascript
 import { StelarServer } from 'stelar-time-real';
 
-// Namespace principal
+// Main namespace
 const main = new StelarServer({ server, namespace: '/' });
 
-// Namespace de chat
+// Chat namespace
 const chat = StelarServer.of('/chat', { server });
 chat.on('message', (ctx) => {
   ctx.broadcast('message', ctx.data);
 });
 
-// Namespace de game
+// Game namespace
 const game = StelarServer.of('/game', { server });
 game.on('move', (ctx) => {
   ctx.to(ctx.data.room, 'move', ctx.data);
@@ -232,45 +232,45 @@ game.on('move', (ctx) => {
 
 #### ACK (Request-Response)
 
-Sistema ultra eficiente con Promesas:
+Ultra efficient system with Promises:
 
-**Servidor:**
+**Server:**
 
 ```javascript
-// Registrar un ACK handler
+// Register an ACK handler
 stelar.onAck('getUser', (ctx) => {
   return { id: ctx.data.id, name: 'John' };
 });
 
-// O con lógica más compleja
+// Or with more complex logic
 stelar.onAck('saveData', (ctx) => {
   const result = saveToDatabase(ctx.data);
   return { success: true, id: result.id };
 });
 ```
 
-**Cliente:**
+**Client:**
 
 ```javascript
-// Usando request() - retorna Promise
+// Using request() - returns Promise
 const user = await client.request('getUser', { id: 1 }, 'userData');
 console.log(user); // { id: 1, name: 'John' }
 
-// O emitiendo con callback
+// Or emit with callback
 client.emit('getUser', { id: 1 }, { ack: 'userData' });
 client.on('userData', (data) => {
   console.log(data);
 });
 
-// ACK desde el servidor al cliente
+// ACK from server to client
 client.onAck('serverPush', (data) => {
-  console.log('El servidor envió:', data);
+  console.log('Server sent:', data);
 });
 ```
 
 ---
 
-### StelarClient (Lado del Cliente)
+### StelarClient (Client Side)
 
 #### Constructor
 
@@ -278,22 +278,22 @@ client.onAck('serverPush', (data) => {
 new StelarClient(urlOrPort, options)
 ```
 
-| Param | Tipo | Default | Descripción |
+| Param | Type | Default | Description |
 |-------|------|---------|-------------|
-| urlOrPort | string/number | localhost:3000 | URL o puerto del servidor |
-| options.reconnection | boolean | true | Reconectar automáticamente |
-| options.reconnectionAttempts | number | 5 | Intentos de reconexión |
-| options.reconnectionDelay | number | 1000 | Delay entre intentos (ms) |
-| options.heartbeatInterval | number | 30000 | Intervalo de ping |
+| urlOrPort | string/number | localhost:3000 | Server URL or port |
+| options.reconnection | boolean | true | Auto reconnect |
+| options.reconnectionAttempts | number | 5 | Reconnection attempts |
+| options.reconnectionDelay | number | 1000 | Delay between attempts (ms) |
+| options.heartbeatInterval | number | 30000 | Ping interval |
 
 ```javascript
-// Solo puerto
+// Just port
 const client = new StelarClient(3000);
 
-// URL completa
-const client = new StelarClient('ws://midominio.com/ws');
+// Full URL
+const client = new StelarClient('ws://mydomain.com/ws');
 
-// Con opciones
+// With options
 const client = new StelarClient(3000, {
   reconnection: true,
   reconnectionAttempts: 10,
@@ -301,19 +301,19 @@ const client = new StelarClient(3000, {
 });
 ```
 
-#### Métodos
+#### Methods
 
 **`.on(event, handler)`**
-Escuchar eventos del servidor.
+Listen for server events.
 
 ```javascript
-client.on('bienvenida', (data) => {
+client.on('welcome', (data) => {
   console.log(data);
 });
 ```
 
 **`.onAll(handler)`**
-Escuchar todos los eventos.
+Listen for all events.
 
 ```javascript
 client.onAll(({ event, data }) => {
@@ -322,93 +322,93 @@ client.onAll(({ event, data }) => {
 ```
 
 **`.onAck(name, handler)`**
-Escuchar respuestas de ACK del servidor.
+Listen for ACK responses from the server.
 
 ```javascript
 client.onAck('userData', (data) => {
-  console.log('Datos recibidos:', data);
+  console.log('Data received:', data);
 });
 ```
 
 **`.emit(event, data, opts)`**
-Enviar eventos al servidor. Soporta `opts.ack` para ACKs.
+Send events to the server. Supports `opts.ack` for ACKs.
 
 ```javascript
-client.emit('chat', { mensaje: 'Hola!' });
+client.emit('chat', { message: 'Hello!' });
 client.emit('getUser', { id: 1 }, { ack: 'userData' });
 ```
 
 **`.request(event, data, ackName)`**
-Enviar y esperar respuesta como Promise.
+Send and wait for response as Promise.
 
 ```javascript
 const result = await client.request('getUser', { id: 1 }, 'userData');
 console.log(result); // { id: 1, name: 'John' }
 
-// Con timeout opcional
+// With optional timeout
 const client = new StelarClient(3000, { ackTimeout: 10000 });
 ```
 
 **`.joinRoom(room)`**
-Unirse a una sala.
+Join a room.
 
 ```javascript
-client.joinRoom('sala-1');
+client.joinRoom('room-1');
 ```
 
 **`.leaveRoom()`**
-Salir de la sala actual.
+Leave current room.
 
 ```javascript
 client.leaveRoom();
 ```
 
 **`.connect(callback)`**
-Conectar al servidor.
+Connect to the server.
 
 ```javascript
 client.connect(() => {
-  console.log('Conectado!');
+  console.log('Connected!');
 });
 ```
 
 **`.disconnect()`**
-Desconectar manualmente.
+Manually disconnect.
 
 ```javascript
 client.disconnect();
 ```
 
 **`.isConnected()`**
-Verificar estado de conexión.
+Check connection status.
 
 ```javascript
 if (client.isConnected()) {
-  console.log('Conectado');
+  console.log('Connected');
 }
 ```
 
 **`.getUrl()`**
-Obtener la URL de conexión.
+Get connection URL.
 
 ```javascript
 console.log(client.getUrl());
 ```
 
-#### Eventos del Cliente
+#### Client Events
 
 ```javascript
-client.on('connect', () => {});       // Cuando se conecta
-client.on('disconnect', () => {});     // Cuando se desconecta
-client.on('reconnecting', (attempt) => {}); // Cuando intenta reconectar
-client.on('error', (err) => {});      // Cuando hay error
+client.on('connect', () => {});       // When connected
+client.on('disconnect', () => {});     // When disconnected
+client.on('reconnecting', (attempt) => {}); // When trying to reconnect
+client.on('error', (err) => {});      // When there's an error
 ```
 
 ---
 
-## Ejemplos
+## Examples
 
-### Chat Básico
+### Basic Chat
 
 **server.js**
 ```javascript
@@ -421,7 +421,7 @@ const server = app.listen(3000);
 const stelar = new StelarServer({ server });
 
 stelar.onConnection((client) => {
-  client.broadcast('system', 'Un usuario se unió');
+  client.broadcast('system', 'A user joined');
 });
 
 stelar.on('chat', (ctx) => {
@@ -429,7 +429,7 @@ stelar.on('chat', (ctx) => {
 });
 
 stelar.start();
-console.log('Chat en http://localhost:3000');
+console.log('Chat at http://localhost:3000');
 ```
 
 **cliente.html**
@@ -439,51 +439,51 @@ console.log('Chat en http://localhost:3000');
 
   const client = new StelarClient(3000);
 
-  client.on('connect', () => console.log('Conectado'));
+  client.on('connect', () => console.log('Connected'));
   client.on('chat', (msg) => console.log('Chat:', msg));
-  client.on('system', (msg) => console.log('Sistema:', msg));
+  client.on('system', (msg) => console.log('System:', msg));
 
   client.connect();
 
-  // Enviar mensajes
-  function enviar(mensaje) {
-    client.emit('chat', mensaje);
+  // Send messages
+  function send(message) {
+    client.emit('chat', message);
   }
 </script>
 ```
 
-### Sistema de Rooms
+### Room System
 
 ```javascript
-// Servidor
-stelar.on('unirse-sala', (ctx) => {
-  const sala = ctx.data.sala;
-  ctx.joinRoom(sala);
-  ctx.emit('bienvenida', `Te uniste a ${sala}`);
+// Server
+stelar.on('join-room', (ctx) => {
+  const room = ctx.data.room;
+  ctx.joinRoom(room);
+  ctx.emit('welcome', `You joined ${room}`);
 });
 
-stelar.on('mensaje-sala', (ctx) => {
-  ctx.to(ctx.data.sala, 'mensaje-sala', ctx.data.mensaje);
+stelar.on('room-message', (ctx) => {
+  ctx.to(ctx.data.room, 'room-message', ctx.data.message);
 });
 
-// Cliente
-client.on('unirse-sala', (sala) => client.joinRoom(sala));
+// Client
+client.on('join-room', (room) => client.joinRoom(room));
 ```
 
-### Con Middleware de Auth
+### With Auth Middleware
 
 ```javascript
 stelar.use((ctx, next) => {
   const token = ctx.req.headers['authorization'];
   if (token && token.startsWith('Bearer ')) {
-    next(); // Permitir conexión
+    next(); // Allow connection
   } else {
-    ctx.socket.close(); // Rechazar
+    ctx.socket.close(); // Reject
   }
 });
 ```
 
-### Con Reconexión Automática
+### With Auto Reconnection
 
 ```javascript
 import { StelarClient } from 'stelar-time-real';
@@ -494,28 +494,28 @@ const client = new StelarClient('localhost:3000', {
   reconnectionDelay: 1000
 });
 
-client.on('connect', () => console.log('Conectado!'));
-client.on('disconnect', () => console.log('Desconectado'));
-client.on('reconnecting', (attempt) => console.log(`Reintentando ${attempt}/5`));
+client.on('connect', () => console.log('Connected!'));
+client.on('disconnect', () => console.log('Disconnected'));
+client.on('reconnecting', (attempt) => console.log(`Retrying ${attempt}/5`));
 
 client.connect();
 ```
 
-### Enviar Archivos Binarios
+### Send Binary Files
 
 ```javascript
-// Servidor - recibir imagen
+// Server - receive image
 stelar.on('image', (ctx) => {
-  // ctx.buffer es un Uint8Array
-  console.log('Recibido:', ctx.buffer.byteLength, 'bytes');
-  // Guardar o procesar la imagen
+  // ctx.buffer is a Uint8Array
+  console.log('Received:', ctx.buffer.byteLength, 'bytes');
+  // Save or process the image
   saveImage(ctx.buffer);
 
-  // Responder al cliente
+  // Respond to client
   ctx.emit('imageSaved', { success: true });
 });
 
-// Cliente - enviar imagen
+// Client - send image
 const input = document.querySelector('input[type="file"]');
 input.addEventListener('change', async (e) => {
   const file = e.target.files[0];
@@ -523,7 +523,7 @@ input.addEventListener('change', async (e) => {
   client.emitBinary('image', buffer);
 });
 
-// Cliente - recibir imagen
+// Client - receive image
 client.on('image', (buffer) => {
   const blob = new Blob([buffer], { type: 'image/png' });
   const url = URL.createObjectURL(blob);
@@ -531,35 +531,35 @@ client.on('image', (buffer) => {
 });
 ```
 
-### Broadcast de Binarios
+### Binary Broadcast
 
 ```javascript
-// Servidor - compartir archivo con todos
+// Server - share file with everyone
 stelar.on('upload', (ctx) => {
   ctx.broadcastBinary('file', ctx.buffer);
 });
 
-// Cliente - enviar archivo
+// Client - send file
 const fileData = await file.arrayBuffer();
 client.emitBinary('upload', fileData);
 ```
 
 ---
 
-## Diferencia con Socket.io
+## Difference with Socket.io
 
-| Característica | stelar-time-real | Socket.io |
-|----------------|------------------|-----------|
-| Tamaño heap | ~13 MB | ~50-100 MB |
-| Dependencias | ws (1) | múltiples |
-| Configuración | mínima | compleja |
-| Flexibilidad | total | opinionada |
-| Ideal para | proyectos propios | producción rápida |
+| Feature | stelar-time-real | Socket.io |
+|---------|------------------|-----------|
+| Heap size | ~13 MB | ~50-100 MB |
+| Dependencies | ws (1) | multiple |
+| Configuration | minimal | complex |
+| Flexibility | total | opinionated |
+| Ideal for | own projects | quick production |
 
-## Licencia
+## License
 
 MIT - Stelar
 
-## Autor
+## Author
 
 Stelar

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stelar-time-real",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "WebSocket liviano y rápido sin dependendas en TypeScript. Alternativa a socket.io, namespaces, ACKs y archivos binarios.",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
@@ -22,12 +22,12 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/stelar-time-real/stelar-time-real"
+    "url": "https://github.com/foxytp/stelar-time-real"
   },
   "bugs": {
-    "url": "https://github.com/stelar-time-real/stelar-time-real/issues"
+    "url": "https://github.com/foxytp/stelar-time-real/issues"
   },
-  "homepage": "https://github.com/stelar-time-real/stelar-time-real#readme",
+  "homepage": "https://github.com/foxytp/stelar-time-real#readme",
   "exports": {
     ".": "./src/index.js",
     "./client": "./src/client.js",