NEW: translation EN (current websockets.md file) to ES (new websockets

.es.md file)

Author: TheHandyOwl

docs/advanced/websockets.es.md

@@ -1,10 +1,10 @@
 # WebSockets
 
-[WebSockets](https://en.wikipedia.org/wiki/WebSocket) allow for two-way communication between a client and server. Unlike HTTP, which has a request and response pattern, WebSocket peers can send an arbitrary number of messages in either direction. Vapor's WebSocket API allows you to create both clients and servers that handle messages asynchronously.
+[WebSockets](https://en.wikipedia.org/wiki/WebSocket) permiten la comunicación bidireccional entre un cliente y un servidor. A diferencia de HTTP, que tiene un patrón de solicitud y respuesta, los pares de WebSocket pueden enviar una cantidad arbitraria de mensajes en cualquier dirección. La API WebSocket de Vapor te permite crear tanto clientes como servidores que manejan mensajes de forma asincrónica.
 
-## Server
+## Servidor
 
-WebSocket endpoints can be added to your existing Vapor application using the Routing API. Use the `webSocket` method like you would use `get` or `post`. 
+Los endpoints de WebSocket se pueden agregar a tu aplicación Vapor existente mediante la API de enrutamiento. Usa el método `webSocket` como usarías `get` o `post`.
 
 ```swift
 app.webSocket("echo") { req, ws in
@@ -13,122 +13,123 @@ app.webSocket("echo") { req, ws in
 }
 ```
 
-WebSocket routes can be grouped and protected by middleware like normal routes. 
+Las rutas de WebSocket se pueden agrupar y proteger mediante middleware como las rutas normales.
 
-In addition to accepting the incoming HTTP request, WebSocket handlers accept the newly established WebSocket connection. See below for more information on using this WebSocket to send and read messages.
+Además de aceptar la solicitud HTTP entrante, los controladores de WebSocket aceptan la conexión WebSocket recién establecida. Consulta a continuación para obtener más información sobre el uso de este WebSocket para enviar y leer mensajes.
 
-## Client
+## Cliente
 
-To connect to a remote WebSocket endpoint, use `WebSocket.connect`. 
+Para conectarse a un endpoint remoto de WebSocket, use `WebSocket.connect`.
 
 ```swift
 WebSocket.connect(to: "ws://echo.websocket.org", on: eventLoop) { ws in
-    // Connected WebSocket.
+    // WebSocket conectado.
     print(ws)
 }
 ```
 
-The `connect` method returns a future that completes when the connection is established. Once connected, the supplied closure will be called with the newly connected WebSocket. See below for more information on using this WebSocket to send and read messages.
+El método `connect` devuelve un futuro que se completa cuando se establece la conexión. Una vez conectado, se llamará al closure proporcionado con el WebSocket recién conectado. Mira más información a continuación sobre el uso de este WebSocket para enviar y leer mensajes.
 
-## Messages
+## Mensajes
 
-The `WebSocket` class has methods for sending and receiving messages as well as listening for events like closure. WebSockets can transmit data via two protocols: text and binary. Text messages are interpreted as UTF-8 strings while binary data is interpreted as an array of bytes.
+La clase `WebSocket` tiene métodos para enviar y recibir mensajes, así como para escuchar eventos como el closure. Los WebSockets pueden transmitir datos a través de dos protocolos: texto y binario. Los mensajes de texto se interpretan como cadenas UTF-8, mientras que los datos binarios se interpretan como una matriz de bytes.
 
-### Sending
+### Envío
 
-Messages can be sent using the WebSocket's `send` method.
+Los mensajes se pueden enviar utilizando el método `send` de WebSocket.
 
 ```swift
 ws.send("Hello, world")
 ```
 
-Passing a `String` to this method results in a text message being sent. Binary messages can be sent by passing a `[UInt8]`. 
+Pasar una `String` a este método da como resultado el envío de un mensaje de texto. Los mensajes binarios se pueden enviar pasando un `[UInt8]`.
 
 ```swift
 ws.send([1, 2, 3])
 ```
 
-Message sending is asynchronous. You can supply an `EventLoopPromise` to the send method to be notified when the message has finished sending or failed to send. 
+El envío de mensajes es asincrónico. Puede proporcionar un `EventLoopPromise` al método de envío para recibir una notificación cuando el mensaje haya terminado de enviarse o falle en el envío.
 
 ```swift
 let promise = eventLoop.makePromise(of: Void.self)
 ws.send(..., promise: promise)
 promise.futureResult.whenComplete { result in
-    // Succeeded or failed to send.
+    // Envío exitoso o fallido.
 }
 ```
 
-If using `async`/`await` you can use `await` to wait for the asynchronous operation to complete
+Si usas `async`/`await`, puedes usar `await` para esperar a que se complete la operación asincrónica
 
 ```swift
 try await ws.send(...)
 ```
 
-### Receiving
+### Recepción
 
-Incoming messages are handled via the `onText` and `onBinary` callbacks.
+Los mensajes entrantes se manejan a través de los callbacks `onText` y `onBinary`.
 
 ```swift
 ws.onText { ws, text in
-    // String received by this WebSocket.
+    // Cadena recibida por este WebSocket.
     print(text)
 }
 
 ws.onBinary { ws, binary in
-    // [UInt8] received by this WebSocket.
+    // [UInt8] recibido por este WebSocket.
     print(binary)
 }
 ```
 
-The WebSocket itself is supplied as the first parameter to these callbacks to prevent reference cycles. Use this reference to take action on the WebSocket after receiving data. For example, to send a reply:
+El propio WebSocket se proporciona como el primer parámetro de estos callbacks para evitar ciclos de referencia. Usa esta referencia para realizar una acción en el WebSocket después de recibir datos. Por ejemplo, para enviar una respuesta:
 
 ```swift
-// Echoes received messages.
+// Se hace eco de los mensajes recibidos.
 ws.onText { ws, text in
     ws.send(text)
 }
 ```
 
-## Closing
+## Cierre
 
-To close a WebSocket, call the `close` method. 
+Para cerrar un WebSocket, llama al método `close`.
 
 ```swift
 ws.close()
 ```
 
-This method returns a future that will be completed when the WebSocket has closed. Like `send`, you may also pass a promise to this method.
+Este método devuelve un futuro que se completará cuando el WebSocket se haya cerrado. Al igual que `send`, también puede pasar una promesa a este método.
 
 ```swift
 ws.close(promise: nil)
 ```
 
-Or `await` on it if using `async`/`await`:
+O `await` si usas `async`/`await`:
 
 ```swift
 try await ws.close()
 ```
 
-To be notified when the peer closes the connection, use `onClose`. This future will be completed when either the client or server closes the WebSocket.
+Para recibir una notificación cuando el par cierra la conexión, utiliza `onClose`. Este futuro se completará cuando el cliente o el servidor cierren el WebSocket.
 
 ```swift
 ws.onClose.whenComplete { result in
-    // Succeeded or failed to close.
+    // Cierre exitoso o fallido.
 }
 ```
 
-The `closeCode` property is set when the WebSocket closes. This can be used to determine why the peer closed the connection.
+La propiedad `closeCode` se establece cuando el WebSocket se cierra. Esto se puede utilizar para determinar por qué el par cerró la conexión.
 
 ## Ping / Pong
 
 Ping and pong messages are sent automatically by the client and server to keep WebSocket connections alive. Your application can listen for these events using the `onPing` and `onPong` callbacks.
+El cliente y el servidor envían automáticamente mensajes de ping y pong para mantener activas las conexiones WebSocket. Su aplicación puede escuchar estos eventos mediante los callbacks `onPing` y `onPong`.
 
 ```swift
 ws.onPing { ws in 
-    // Ping was received.
+    // Se recibió ping.
 }
 
 ws.onPong { ws in
-    // Pong was received.
+    // Se recibió pong.
 }
 ```