Quark #

Modules #

Quark v1.4.0 Documentation

Contents

quark/net #

SocketEvent # 

type SocketEvent<T = void> = Event<Socket,T>

WSocketEvent # 

type WSocketEvent<T = void> = Event<WebSocket,T>

Class: NativeSocket #

NativeSocket #

Extends: Notification<SocketEvent>

nativesocket.hostname #

Hostname of the WebSocket server

readonly hostname: string

nativesocket.port #

Port of the WebSocket server

readonly port: Uint

nativesocket.ip #

IP address for the remote server

readonly ip: string

nativesocket.ipv6 #

IPv6 address for the remote server

readonly ipv6: string

nativesocket.isOpen #

true means connection is open

readonly isOpen: boolean

nativesocket.isConnecting #

true means socket is connecting

readonly isConnecting: boolean

nativesocket.isPause #

true means socket is paused

readonly isPause: boolean

nativesocket.setKeepAlive(keep_alive,keep_idle?) # 

setKeepAlive(keep_alive: boolean, keep_idle?: Uint): void

nativesocket.setNoDelay(noDelay?) # 

setNoDelay(noDelay?: boolean): void

nativesocket.setTimeout(time) # 

setTimeout(time: Uint): void

nativesocket.connect() # 

connect(): void

nativesocket.close() # 

close(): void

nativesocket.pause() # 

pause(): void

nativesocket.resume() # 

resume(): void

nativesocket.disableSslVerify(disable?) # 

disableSslVerify(disable?: boolean): void

nativesocket.constructor(hostname,port,isSSL?) # 

constructor(hostname: string, port: Uint, isSSL?: boolean)

Class: Socket #

Socket #

Extends: NativeSocket

socket.onOpen #

Trigger when opened connection

socket.onClose #

Trigger when closed connection

socket.onError #

Trigger when an error occurs

socket.onData #

Trigger when accept part of body data, and will be continuous

socket.onTimeout #

Trigger when a timeout of connection

socket.write(data) # 

write(data: string | Uint8Array): Promise<void>

Interface: Signer #

Signer #

Signer interface for signing data.

Class: WebSocket #

WebSocket #

WebSocket client conversation.

Extends: Notification<WSocketEvent> Implements: Stream

For example:

import {WebSocket} from 'quark/net';
let ws = new WebSocket('wss://example.com/path');
ws.onOpen.on(()=>{
  console.log('WebSocket opened');
  ws.write('Hello, WebSocket!');
});
ws.onData.on(e=>{
  console.log('Received data:', e.data);
});
ws.onError.on(e=>{
  console.error('WebSocket error:', e.data);
});
ws.onClose.on(()=>{
  console.log('WebSocket closed');
});
ws.connect();

websocket.url #

URL of the WebSocket server

readonly url: URL

websocket.hostname #

Hostname of the WebSocket server

readonly hostname: string

websocket.port #

Port number

readonly port: Uint

websocket.isSSL #

true means wss, false means ws

readonly isSSL: boolean

websocket.socket #

Socket connection implementation

readonly socket: Socket

websocket.headers #

request headers

readonly headers: Dict<string>

websocket.responseHeaders #

Response headers

readonly responseHeaders: Dict<string>

websocket.signer #

A signer, use to sign the request

signer: Signer | null

websocket.ip #

ip address for the remote server

readonly ip: string

websocket.ipv6 #

ipv6 address for the remote server

readonly ipv6: string

websocket.isOpen #

true means connection is open

readonly isOpen: boolean

websocket.isPause #

true means socket is paused

readonly isPause: boolean

websocket.isConnecting #

true means socket is connecting

readonly isConnecting: boolean

websocket.onOpen #

Trigger when opened connection

websocket.onClose #

Trigger when closed connection

websocket.onError #

Trigger when an error occurs

websocket.onPing #

Trigger when accept ping message

websocket.onPong #

Trigger when accept pong message

websocket.onData #

Trigger when accept buffer data

websocket.onText #

Trigger when accept text data

websocket.onTimeout #

Trigger when a timeout of connection

websocket.constructor(url) # 

constructor(url: string)

Parameters:

  • url — wss://xxxx.xx/path

websocket.setKeepAlive(keep_alive,keep_idle?) #

Setting keep alive for the socket connection

setKeepAlive(keep_alive: boolean, keep_idle?: Uint)

Parameters:

  • keep_alive — enable keep alive
  • keep_idle? — Default is 0 means 7200 seconds, the time in milliseconds to wait before sending keep alive packets

websocket.setTimeout(time) #

Setting timeout time for the socket connection

setTimeout(time: Uint)

websocket.connect() #

Connect to the WebSocket server

connect()

websocket.close() #

Close the WebSocket connection

close()

websocket.pause() #

Pause receiving data from the socket

pause()

websocket.resume() #

Resuming receiving data from the socket

resume()

websocket.write(data) #

Sending the data message. Frame client-to-server output as a text packet or buffer packet.

write(data: string | Uint8Array): Promise<void>

websocket.send(data) #

alias for write

send(data: string | Uint8Array): Promise<void>

websocket.ping() #

Sending the ping message

ping(): Promise<void>

websocket.test(timeoutMs?) #

First send the ping message to the remote client then wait for the pong message

test(timeoutMs?: Uint): Promise<void>

Parameters:

  • timeoutMs? — wait for the pong message, default not timeout

websocket.disableSslVerify(disable) #

Setting if is disable ssl verify

disableSslVerify(disable: boolean)

Parameters:

  • disable — True means disable ssl verify

websocket.triggerOpen() # 

triggerOpen()

websocket.triggerClose() # 

triggerClose()

websocket.triggerError(err) # 

triggerError(err: Error)

websocket.triggerPing() # 

triggerPing()

websocket.triggerPong() # 

triggerPong()

websocket.triggerData(data) # 

triggerData(data: Buffer)

websocket.triggerText(text) # 

triggerText(text: string)

websocket.triggerTimeout() # 

triggerTimeout()