socket

package
v1.0.21 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 22, 2023 License: MIT Imports: 26 Imported by: 19

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var NAMESPACE_RESERVED_EVENTS = types.NewSet("connect", "connection", "new_namespace")
View Source 
var (
	SOCKET_RESERVED_EVENTS = types.NewSet("connect", "connect_error", "disconnect", "disconnecting", "newListener", "removeListener")
)

Functions

This section is empty.

Types

type Adapter 

type Adapter interface {
	New(NamespaceInterface) Adapter

	Rooms() *sync.Map
	Sids() *sync.Map
	Nsp() NamespaceInterface

	// To be overridden
	Init()

	// To be overridden
	Close()

	// Returns the number of Socket.IO servers in the cluster
	ServerCount() int64

	// Adds a socket to a list of room.
	AddAll(SocketId, *types.Set[Room])

	// Removes a socket from a room.
	Del(SocketId, Room)

	// Removes a socket from all rooms it's joined.
	DelAll(SocketId)

	SetBroadcast(func(*parser.Packet, *BroadcastOptions))
	// Broadcasts a packet.
	//
	// Options:
	//  - `Flags` {*BroadcastFlags} flags for this packet
	//  - `Except` {*types.Set[Room]} sids that should be excluded
	//  - `Rooms` {*types.Set[Room]} list of rooms to broadcast to
	Broadcast(*parser.Packet, *BroadcastOptions)

	// Broadcasts a packet and expects multiple acknowledgements.
	//
	// Options:
	//  - `Flags` {*BroadcastFlags} flags for this packet
	//  - `Except` {*types.Set[Room]} sids that should be excluded
	//  - `Rooms` {*types.Set[Room]} list of rooms to broadcast to
	BroadcastWithAck(*parser.Packet, *BroadcastOptions, func(uint64), func(...any))

	// Gets a list of sockets by sid.
	Sockets(*types.Set[Room]) *types.Set[SocketId]

	// Gets the list of rooms a given socket has joined.
	SocketRooms(SocketId) *types.Set[Room]

	// Returns the matching socket instances
	FetchSockets(*BroadcastOptions) []any

	// Makes the matching socket instances join the specified rooms
	AddSockets(*BroadcastOptions, []Room)

	// Makes the matching socket instances leave the specified rooms
	DelSockets(*BroadcastOptions, []Room)

	// Makes the matching socket instances disconnect
	DisconnectSockets(*BroadcastOptions, bool)

	// Send a packet to the other Socket.IO servers in the cluster
	ServerSideEmit(string, ...any) error
}

type BroadcastFlags 

type BroadcastFlags struct {
	WriteOptions

	Local     bool
	Broadcast bool
	Binary    bool
	Timeout   *time.Duration
}

type BroadcastOperator 

type BroadcastOperator struct {
	// contains filtered or unexported fields
}

func NewBroadcastOperator 

func NewBroadcastOperator(adapter Adapter, rooms *types.Set[Room], exceptRooms *types.Set[Room], flags *BroadcastFlags) *BroadcastOperator

func (*BroadcastOperator) AllSockets deprecated 

func (b *BroadcastOperator) AllSockets() (*types.Set[SocketId], error)

Gets a list of clients.

Deprecated: this method will be removed in the next major release, please use *Server.ServerSideEmit or *BroadcastOperator.FetchSockets instead.

func (*BroadcastOperator) Compress 

func (b *BroadcastOperator) Compress(compress bool) *BroadcastOperator

Sets the compress flag. 

io.Compress(false).Emit("hello")

func (*BroadcastOperator) DisconnectSockets 

func (b *BroadcastOperator) DisconnectSockets(status bool)

Makes the matching socket instances disconnect.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances disconnect (the connections might be kept alive for other namespaces)
io.DisconnectSockets(false)

// make all socket instances in the "room1" room disconnect and close the underlying connections
io.In("room1").DisconnectSockets(true)

func (*BroadcastOperator) Emit 

func (b *BroadcastOperator) Emit(ev string, args ...any) error

Emits to all clients. 

// the “foo” event will be broadcast to all connected clients
io.Emit("foo", "bar")

// the “foo” event will be broadcast to all connected clients in the “room-101” room
io.To("room-101").Emit("foo", "bar")

// with an acknowledgement expected from all connected clients
io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

func (*BroadcastOperator) Except 

func (b *BroadcastOperator) Except(room ...Room) *BroadcastOperator

Excludes a room when emitting. 

// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
io.Except("room-101").Emit("foo", "bar")

// with an array of rooms
io.Except(["room-101", "room-102"]).Emit("foo", "bar")
io.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.Except("room-101").Except("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) FetchSockets 

func (b *BroadcastOperator) FetchSockets() (remoteSockets []*RemoteSocket)

Returns the matching socket instances. This method works across a cluster of several Socket.IO servers.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// return all Socket instances
sockets := io.FetchSockets()

// return all Socket instances in the "room1" room
sockets := io.In("room1").FetchSockets()

for _, socket := range sockets {
	fmt.Println(socket.Id())
	fmt.Println(socket.Handshake())
	fmt.Println(socket.Rooms())
	fmt.Println(socket.Data())

	socket.Emit("hello")
	socket.Join("room1")
	socket.Leave("room2")
	socket.Disconnect()
}

func (*BroadcastOperator) In 

func (b *BroadcastOperator) In(room ...Room) *BroadcastOperator

Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases: 

// disconnect all clients in the "room-101" room
io.In("room-101").DisconnectSockets(false)

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) Local 

func (b *BroadcastOperator) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

// the “foo” event will be broadcast to all connected clients on this node
io.Local().Emit("foo", "bar")

Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) SocketsJoin 

func (b *BroadcastOperator) SocketsJoin(room ...Room)

Makes the matching socket instances join the specified rooms.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances join the "room1" room
io.SocketsJoin("room1")

// make all socket instances in the "room1" room join the "room2" and "room3" rooms
io.In("room1").SocketsJoin([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*BroadcastOperator) SocketsLeave 

func (b *BroadcastOperator) SocketsLeave(room ...Room)

Makes the matching socket instances leave the specified rooms.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances leave the "room1" room
io.SocketsLeave("room1")

// make all socket instances in the "room1" room leave the "room2" and "room3" rooms
io.In("room1").SocketsLeave([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*BroadcastOperator) Timeout 

func (b *BroadcastOperator) Timeout(timeout time.Duration) *BroadcastOperator

Adds a timeout in milliseconds for the next operation 

io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

func (*BroadcastOperator) To 

func (b *BroadcastOperator) To(room ...Room) *BroadcastOperator

Targets a room when emitting. 

// the “foo” event will be broadcast to all connected clients in the “room-101” room
io.To("room-101").Emit("foo", "bar")

// with an array of rooms (a client will be notified at most once)
io.To("room-101", "room-102").Emit("foo", "bar")
io.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.To("room-101").To("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) Volatile 

func (b *BroadcastOperator) Volatile() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.Volatile().Emit("hello") // the clients may or may not receive it

type BroadcastOptions 

type BroadcastOptions struct {
	Rooms  *types.Set[Room]
	Except *types.Set[Room]
	Flags  *BroadcastFlags
}

type Client 

type Client struct {
	// contains filtered or unexported fields
}

func NewClient 

func NewClient(server *Server, conn engine.Socket) *Client

Client constructor.

func (*Client) Conn added in v1.0.2 

func (c *Client) Conn() engine.Socket

func (*Client) Request 

func (c *Client) Request() *types.HttpContext

func (*Client) WriteToEngine 

func (c *Client) WriteToEngine(encodedPackets []types.BufferInterface, opts *WriteOptions)

type ExtendedError 

type ExtendedError struct {
	// contains filtered or unexported fields
}

func NewExtendedError 

func NewExtendedError(message string, data any) *ExtendedError

func (*ExtendedError) Data 

func (e *ExtendedError) Data() any

func (*ExtendedError) Err 

func (e *ExtendedError) Err() error

func (*ExtendedError) Error 

func (e *ExtendedError) Error() string

type Handshake 

type Handshake struct {
	// The headers sent as part of the handshake
	Headers *utils.ParameterBag
	// The date of creation (as string)
	Time string
	// The ip of the client
	Address string
	// Whether the connection is cross-domain
	Xdomain bool
	// Whether the connection is secure
	Secure bool
	// The date of creation (as unix timestamp)
	Issued int64
	// The request URL string
	Url string
	// The query object
	Query *utils.ParameterBag
	// The auth object
	Auth any
}

type Namespace 

type Namespace struct {
	*StrictEventEmitter
	// contains filtered or unexported fields
}

func NewNamespace 

func NewNamespace(server *Server, name string) *Namespace

A Namespace is a communication channel that allows you to split the logic of your application over a single shared connection.

Each namespace has its own:

- event handlers 

io.Of("/orders").On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.On("order:list", func(...any){})
	socket.On("order:create", func(...any){})
})

io.Of("/users").On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.On("user:list", func(...any){})
})

- rooms 

orderNamespace := io.Of("/orders")

orderNamespace.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.Join("room1")
	orderNamespace.To("room1").Emit("hello")
})

userNamespace := io.Of("/users")

userNamespace.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.Join("room1") // distinct from the room in the "orders" namespace
	userNamespace.To("room1").Emit("holà")
})

- middlewares 

orderNamespace := io.Of("/orders")

orderNamespace.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ensure the socket has access to the "orders" namespace
})

userNamespace := io.Of("/users")

userNamespace.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ensure the socket has access to the "users" namespace
})

func (*Namespace) Adapter 

func (n *Namespace) Adapter() Adapter

func (*Namespace) Add 

func (n *Namespace) Add(client *Client, query any, fn func(*Socket)) *Socket

Adds a new client.

func (*Namespace) AllSockets deprecated 

func (n *Namespace) AllSockets() (*types.Set[SocketId], error)

Gets a list of socket ids.

Deprecated: this method will be removed in the next major release, please use *Server.ServerSideEmit or *BroadcastOperator.FetchSockets instead.

func (*Namespace) Compress 

func (n *Namespace) Compress(compress bool) *BroadcastOperator

Sets the compress flag. 

io.compress(false).emit("hello")

Param: bool - if `true`, compresses the sending data Return: a new *BroadcastOperator instance for chaining

func (*Namespace) DisconnectSockets 

func (n *Namespace) DisconnectSockets(status bool)

Makes the matching socket instances disconnect

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances disconnect (the connections might be kept alive for other namespaces)
io.DisconnectSockets(false)

// make all socket instances in the "room1" room disconnect and close the underlying connections
io.In("room1").DisconnectSockets(true)

func (*Namespace) Emit 

func (n *Namespace) Emit(ev string, args ...any) error

Emits to all clients. 

myNamespace := io.Of("/my-namespace")

// the “foo” event will be broadcast to all connected clients
myNamespace.Emit("foo", "bar")

// the “foo” event will be broadcast to all connected clients in the “room-101” room
myNamespace.To("room-101").Emit("foo", "bar")

// with an acknowledgement expected from all connected clients
myNamespace.Timeout(1000 * time.Millisecond).Emit("some-event", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

func (*Namespace) EventEmitter 

func (n *Namespace) EventEmitter() *StrictEventEmitter

func (*Namespace) Except 

func (n *Namespace) Except(room ...Room) *BroadcastOperator

Excludes a room when emitting. 

myNamespace := io.Of("/my-namespace")

// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
myNamespace.Except("room-101").Emit("foo", "bar")

// with an array of rooms
myNamespace.Except(["room-101", "room-102"]).Emit("foo", "bar")
myNamespace.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
myNamespace.Except("room-101").Except("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) FetchSockets 

func (n *Namespace) FetchSockets() ([]*RemoteSocket, error)

Returns the matching socket instances

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// return all Socket instances
sockets := io.FetchSockets()

// return all Socket instances in the "room1" room
sockets := io.In("room1").FetchSockets()

for _, socket := range sockets {
	fmt.Println(socket.Id())
	fmt.Println(socket.Handshake())
	fmt.Println(socket.Rooms())
	fmt.Println(socket.Data())

	socket.Emit("hello")
	socket.Join("room1")
	socket.Leave("room2")
	socket.Disconnect()
}

func (*Namespace) Ids 

func (n *Namespace) Ids() uint64

func (*Namespace) In 

func (n *Namespace) In(room ...Room) *BroadcastOperator

Targets a room when emitting. 

myNamespace := io.Of("/my-namespace")

// disconnect all clients in the "room-101" room
myNamespace.In("room-101").DisconnectSockets(false)

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) Local 

func (n *Namespace) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

// the “foo” event will be broadcast to all connected clients on this node
io.Local().Emit("foo", "bar")

Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) Name 

func (n *Namespace) Name() string

func (*Namespace) Send 

func (n *Namespace) Send(args ...any) NamespaceInterface

Sends a `message` event to all clients.

This method mimics the WebSocket.send() method.

See: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send 

myNamespace := io.Of("/my-namespace")

myNamespace.Send("hello")

// this is equivalent to
myNamespace.Emit("message", "hello")

func (*Namespace) Server 

func (n *Namespace) Server() *Server

func (*Namespace) ServerSideEmit 

func (n *Namespace) ServerSideEmit(ev string, args ...any) error

Emit a packet to other Socket.IO servers 

myNamespace := io.Of("/my-namespace")

myNamespace.ServerSideEmit("hello", "world")

myNamespace.On("hello", func(args ...any) {
	fmt.Println(args) // prints "world"
})

// acknowledgements (without binary content) are supported too:
myNamespace.ServerSideEmit("ping", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

myNamespace.On("ping", func(args ...any) {
	args[0]("pong")
})

func (*Namespace) Sockets 

func (n *Namespace) Sockets() *sync.Map

func (*Namespace) SocketsJoin 

func (n *Namespace) SocketsJoin(room ...Room)

Makes the matching socket instances join the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances join the "room1" room
io.SocketsJoin("room1")

// make all socket instances in the "room1" room join the "room2" and "room3" rooms
io.In("room1").SocketsJoin([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Namespace) SocketsLeave 

func (n *Namespace) SocketsLeave(room ...Room)

Makes the matching socket instances leave the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances leave the "room1" room
io.SocketsLeave("room1")

// make all socket instances in the "room1" room leave the "room2" and "room3" rooms
io.In("room1").SocketsLeave([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Namespace) Timeout 

func (n *Namespace) Timeout(timeout time.Duration) *BroadcastOperator

Adds a timeout in milliseconds for the next operation 

io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

func (*Namespace) To 

func (n *Namespace) To(room ...Room) *BroadcastOperator

Targets a room when emitting. 

myNamespace := io.Of("/my-namespace")

// the “foo” event will be broadcast to all connected clients in the “room-101” room
myNamespace.To("room-101").Emit("foo", "bar")

// with an array of rooms (a client will be notified at most once)
myNamespace.To("room-101", "room-102").Emit("foo", "bar")
myNamespace.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
myNamespace.To("room-101").To("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) Use 

func (n *Namespace) Use(fn func(*Socket, func(*ExtendedError))) NamespaceInterface

Registers a middleware, which is a function that gets executed for every incoming {@link Socket}. 

myNamespace := io.Of("/my-namespace")

myNamespace.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ...
	next(nil)
})

Param: func(*ExtendedError) - the middleware function

func (*Namespace) Volatile 

func (n *Namespace) Volatile() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.Volatile().Emit("hello") // the clients may or may not receive it

func (*Namespace) Write 

func (n *Namespace) Write(args ...any) NamespaceInterface

Sends a `message` event to all clients. Alias of Send.

type NamespaceInterface 

type NamespaceInterface interface {
	EventEmitter() *StrictEventEmitter

	On(string, ...events.Listener) error
	Once(string, ...events.Listener) error
	EmitReserved(string, ...any)
	EmitUntyped(string, ...any)
	Listeners(string) []events.Listener

	Sockets() *sync.Map
	Server() *Server
	Adapter() Adapter
	Name() string
	Ids() uint64

	// Sets up namespace middleware.
	Use(func(*Socket, func(*ExtendedError))) NamespaceInterface

	// Targets a room when emitting.
	To(...Room) *BroadcastOperator

	// Targets a room when emitting.
	In(...Room) *BroadcastOperator

	// Excludes a room when emitting.
	Except(...Room) *BroadcastOperator

	// Adds a new client.
	Add(*Client, any, func(*Socket)) *Socket

	// Emits to all clients.
	Emit(string, ...any) error

	// Sends a `message` event to all clients.
	Send(...any) NamespaceInterface

	// Sends a `message` event to all clients.
	Write(...any) NamespaceInterface

	// Emit a packet to other Socket.IO servers
	ServerSideEmit(string, ...any) error

	// Gets a list of clients.
	AllSockets() (*types.Set[SocketId], error)

	// Sets the compress flag.
	Compress(bool) *BroadcastOperator

	// Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
	// receive messages (because of network slowness or other issues, or because they’re connected through long polling
	// and is in the middle of a request-response cycle).
	Volatile() *BroadcastOperator

	// Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
	Local() *BroadcastOperator

	// Adds a timeout in milliseconds for the next operation
	Timeout(time.Duration) *BroadcastOperator

	// Returns the matching socket instances
	FetchSockets() ([]*RemoteSocket, error)

	// Makes the matching socket instances join the specified rooms
	SocketsJoin(...Room)

	// Makes the matching socket instances leave the specified rooms
	SocketsLeave(...Room)

	// Makes the matching socket instances disconnect
	DisconnectSockets(bool)
}

type ParentNamespace 

type ParentNamespace struct {
	*Namespace
	// contains filtered or unexported fields
}

func NewParentNamespace 

func NewParentNamespace(server *Server) *ParentNamespace

func (*ParentNamespace) CreateChild 

func (p *ParentNamespace) CreateChild(name string) *Namespace

func (*ParentNamespace) Emit 

func (p *ParentNamespace) Emit(ev string, args ...any) error

func (*ParentNamespace) FetchSockets 

func (p *ParentNamespace) FetchSockets() ([]*RemoteSocket, error)

type ParentNspNameMatchFn 

type ParentNspNameMatchFn *func(string, any, func(error, bool))

type RemoteSocket 

type RemoteSocket struct {
	// contains filtered or unexported fields
}

func NewRemoteSocket 

func NewRemoteSocket(adapter Adapter, details SocketDetails) *RemoteSocket

func (*RemoteSocket) Data 

func (r *RemoteSocket) Data() any

func (*RemoteSocket) Disconnect 

func (r *RemoteSocket) Disconnect(status bool) *RemoteSocket

Disconnects this client.

func (*RemoteSocket) Emit 

func (r *RemoteSocket) Emit(ev string, args ...any) error

func (*RemoteSocket) Handshake 

func (r *RemoteSocket) Handshake() *Handshake

func (*RemoteSocket) Id 

func (r *RemoteSocket) Id() SocketId

func (*RemoteSocket) Join 

func (r *RemoteSocket) Join(room ...Room)

Joins a room.

func (*RemoteSocket) Leave 

func (r *RemoteSocket) Leave(room ...Room)

Leaves a room.

func (*RemoteSocket) Rooms 

func (r *RemoteSocket) Rooms() *types.Set[Room]

type Room 

type Room string

type Server 

type Server struct {
	*StrictEventEmitter
	// contains filtered or unexported fields
}

func NewServer 

func NewServer(srv any, opts *ServerOptions) *Server

Represents a Socket.IO server. 

import (
	"github.com/zishang520/engine.io/utils"
	"github.com/zishang520/socket.io/socket"
)

io := socket.NewServer(nil, nil)

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)

	utils.Log().Info(`socket %s connected`, socket.Id())

	// send an event to the client
	socket.Emit("foo", "bar")

	socket.On("foobar", func(...any) {
		// an event was received from the client
	})

	// upon disconnection
	socket.On("disconnect", func(reason ...any) {
		utils.Log().Info(`socket %s disconnected due to %s`, socket.Id(), reason[0])
	})
})
io.Listen(3000, nil)

func (*Server) Adapter 

func (s *Server) Adapter() Adapter

func (*Server) AllSockets deprecated 

func (s *Server) AllSockets() (*types.Set[SocketId], error)

Gets a list of socket ids.

Deprecated: this method will be removed in the next major release, please use *Server.ServerSideEmit or *BroadcastOperator.FetchSockets instead.

func (*Server) Attach 

func (s *Server) Attach(srv any, opts *ServerOptions) *Server

Attaches socket.io to a server or port.

func (*Server) Bind 

func (s *Server) Bind(egs engine.Server) *Server

Binds socket.io to an engine.io instance.

func (*Server) Close 

func (s *Server) Close(fn func())

Closes server connection

func (*Server) Compress 

func (s *Server) Compress(compress bool) *BroadcastOperator

Sets the compress flag. 

io.compress(false).emit("hello")

Param: bool - if `true`, compresses the sending data Return: a new *BroadcastOperator instance for chaining

func (*Server) ConnectTimeout 

func (s *Server) ConnectTimeout() time.Duration

func (*Server) DisconnectSockets 

func (s *Server) DisconnectSockets(status bool)

Makes the matching socket instances disconnect

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances disconnect (the connections might be kept alive for other namespaces)
io.DisconnectSockets(false)

// make all socket instances in the "room1" room disconnect and close the underlying connections
io.In("room1").DisconnectSockets(true)

func (*Server) Encoder 

func (s *Server) Encoder() parser.Encoder

func (*Server) Engine added in v1.0.2 

func (s *Server) Engine() engine.Server

func (*Server) Except 

func (s *Server) Except(room ...Room) *BroadcastOperator

Excludes a room when emitting. 

// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
io.Except("room-101").Emit("foo", "bar")

// with an array of rooms
io.Except(["room-101", "room-102"]).Emit("foo", "bar")
io.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.Except("room-101").Except("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Server) FetchSockets 

func (s *Server) FetchSockets() ([]*RemoteSocket, error)

Returns the matching socket instances

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// return all Socket instances
sockets := io.FetchSockets()

// return all Socket instances in the "room1" room
sockets := io.In("room1").FetchSockets()

for _, socket := range sockets {
	fmt.Println(socket.Id())
	fmt.Println(socket.Handshake())
	fmt.Println(socket.Rooms())
	fmt.Println(socket.Data())

	socket.Emit("hello")
	socket.Join("room1")
	socket.Leave("room2")
	socket.Disconnect()
}

func (*Server) In 

func (s *Server) In(room ...Room) *BroadcastOperator

Targets a room when emitting. 

// disconnect all clients in the "room-101" room
io.In("room-101").DisconnectSockets(false)

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Server) Listen 

func (s *Server) Listen(srv any, opts *ServerOptions) *Server

Attaches socket.io to a server or port.

func (*Server) Local 

func (s *Server) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

// the “foo” event will be broadcast to all connected clients on this node
io.Local().Emit("foo", "bar")

Return: a new `*BroadcastOperator` instance for chaining

func (*Server) Of 

func (s *Server) Of(name any, fn func(...any)) NamespaceInterface

Looks up a namespace. 

// with a simple string
myNamespace := io.Of("/my-namespace")

// with a regex
const dynamicNsp = io.Of(regexp.MustCompile(`^\/dynamic-\d+$`), nil).On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	namespace := socket.Nsp() // newNamespace.Name() === "/dynamic-101"

	// broadcast to all clients in the given sub-namespace
	namespace.Emit("hello")
})

Param: any - nsp name Param: func(...any) - nsp `connection` ev handler

func (*Server) Path 

func (s *Server) Path() string

func (*Server) Send 

func (s *Server) Send(args ...any) *Server

Sends a `message` event to all clients.

This method mimics the WebSocket.send() method.

See: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send 

io.Send("hello")

// this is equivalent to
io.Emit("message", "hello")

func (*Server) ServeClient 

func (s *Server) ServeClient() bool

func (*Server) ServeHandler added in v1.0.11 

func (s *Server) ServeHandler(opts *ServerOptions) http.Handler

func (*Server) ServerSideEmit 

func (s *Server) ServerSideEmit(ev string, args ...any) error

Sends a message to the other Socket.IO servers of the cluster. 

io.ServerSideEmit("hello", "world")

io.On("hello", func(args ...any) {
	fmt.Println(args) // prints "world"
})

// acknowledgements (without binary content) are supported too:
io.ServerSideEmit("ping", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

io.On("ping", func(args ...any) {
	args[0]("pong")
})

func (*Server) SetAdapter 

func (s *Server) SetAdapter(v Adapter) *Server

Sets the adapter for rooms.

func (*Server) SetConnectTimeout 

func (s *Server) SetConnectTimeout(v time.Duration) *Server

Set the delay after which a client without namespace is closed

func (*Server) SetPath 

func (s *Server) SetPath(v string) *Server

Sets the client serving path.

func (*Server) SetServeClient 

func (s *Server) SetServeClient(v bool) *Server

Sets/gets whether client code is being served.

func (*Server) Sockets added in v1.0.3 

func (s *Server) Sockets() NamespaceInterface

func (*Server) SocketsJoin 

func (s *Server) SocketsJoin(room ...Room)

Makes the matching socket instances join the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances join the "room1" room
io.SocketsJoin("room1")

// make all socket instances in the "room1" room join the "room2" and "room3" rooms
io.In("room1").SocketsJoin([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Server) SocketsLeave 

func (s *Server) SocketsLeave(room ...Room)

Makes the matching socket instances leave the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances leave the "room1" room
io.SocketsLeave("room1")

// make all socket instances in the "room1" room leave the "room2" and "room3" rooms
io.In("room1").SocketsLeave([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Server) Timeout 

func (s *Server) Timeout(timeout time.Duration) *BroadcastOperator

Adds a timeout in milliseconds for the next operation 

io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args ...any) {
	if args[0] != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args[1]) // one response per client
	}
})

func (*Server) To 

func (s *Server) To(room ...Room) *BroadcastOperator

Targets a room when emitting. 

// the “foo” event will be broadcast to all connected clients in the “room-101” room
io.To("room-101").Emit("foo", "bar")

// with an array of rooms (a client will be notified at most once)
io.To("room-101", "room-102").Emit("foo", "bar")
io.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.To("room-101").To("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Server) Use 

func (s *Server) Use(fn func(*Socket, func(*ExtendedError))) *Server

Registers a middleware, which is a function that gets executed for every incoming {@link Socket}. 

io.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ...
	next(nil)
})

Param: func(*ExtendedError) - the middleware function

func (*Server) Volatile 

func (s *Server) Volatile() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.Volatile().Emit("hello") // the clients may or may not receive it

func (*Server) Write 

func (s *Server) Write(args ...any) *Server

Sends a `message` event to all clients. Alias of Send.

type ServerOptions 

type ServerOptions struct {
	config.ServerOptions
	config.AttachOptions
	// contains filtered or unexported fields
}

func DefaultServerOptions 

func DefaultServerOptions() *ServerOptions

func (*ServerOptions) Adapter 

func (s *ServerOptions) Adapter() Adapter

func (*ServerOptions) Assign 

func (s *ServerOptions) Assign(data ServerOptionsInterface) (ServerOptionsInterface, error)

func (*ServerOptions) ConnectTimeout 

func (s *ServerOptions) ConnectTimeout() time.Duration

func (*ServerOptions) GetRawAdapter 

func (s *ServerOptions) GetRawAdapter() Adapter

func (*ServerOptions) GetRawConnectTimeout 

func (s *ServerOptions) GetRawConnectTimeout() *time.Duration

func (*ServerOptions) GetRawParser 

func (s *ServerOptions) GetRawParser() parser.Parser

func (*ServerOptions) GetRawServeClient 

func (s *ServerOptions) GetRawServeClient() *bool

func (*ServerOptions) Parser 

func (s *ServerOptions) Parser() parser.Parser

func (*ServerOptions) Path 

func (s *ServerOptions) Path() string

func (*ServerOptions) ServeClient 

func (s *ServerOptions) ServeClient() bool

func (*ServerOptions) SetAdapter 

func (s *ServerOptions) SetAdapter(adapter Adapter)

func (*ServerOptions) SetConnectTimeout 

func (s *ServerOptions) SetConnectTimeout(connectTimeout time.Duration)

func (*ServerOptions) SetParser 

func (s *ServerOptions) SetParser(parser parser.Parser)

func (*ServerOptions) SetServeClient 

func (s *ServerOptions) SetServeClient(serveClient bool)

type ServerOptionsInterface 

type ServerOptionsInterface interface {
	config.ServerOptionsInterface
	config.AttachOptionsInterface

	SetServeClient(serveClient bool)
	GetRawServeClient() *bool
	ServeClient() bool

	SetAdapter(adapter Adapter)
	GetRawAdapter() Adapter
	Adapter() Adapter

	SetParser(parser parser.Parser)
	GetRawParser() parser.Parser
	Parser() parser.Parser

	SetConnectTimeout(connectTimeout time.Duration)
	GetRawConnectTimeout() *time.Duration
	ConnectTimeout() time.Duration
}

type Socket 

type Socket struct {
	*StrictEventEmitter
	// contains filtered or unexported fields
}

func NewSocket 

func NewSocket(nsp *Namespace, client *Client, auth any) *Socket

This is the main object for interacting with a client.

A Socket belongs to a given *socket.Namespace and uses an underlying *socket.Client to communicate.

Within each *socket.Namespace, you can also define arbitrary channels (called "rooms") that the *socket.Socket can join and leave. That provides a convenient way to broadcast to a group of socket instances. 

io.On("connection", On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)

	utils.Log().Info(`socket %s connected`, socket.Id())

	// send an event to the client
	socket.Emit("foo", "bar")

	socket.On("foobar", func(...any) {
		// an event was received from the client
	})

	// join the room named "room1"
	socket.Join("room1")

	// broadcast to everyone in the room named "room1"
	io.to("room1").Emit("hello")

	// upon disconnection
	socket.On("disconnect", func(reason ...any) {
		utils.Log().Info(`socket %s disconnected due to %s`, socket.Id(), reason[0])
	})
})

func (*Socket) Acks 

func (s *Socket) Acks() *sync.Map

func (*Socket) Broadcast 

func (s *Socket) Broadcast() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the sender. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the “foo” event will be broadcast to all connected clients, except this socket
	socket.Broadcast().Emit("foo", "bar")
})

Return: a new *BroadcastOperator instance for chaining

func (*Socket) Client 

func (s *Socket) Client() *Client

func (*Socket) Compress 

func (s *Socket) Compress(compress bool) *Socket

Sets the compress flag. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Compress(false).Emit("hello")
})

func (*Socket) Conn 

func (s *Socket) Conn() engine.Socket

A reference to the underlying Client transport connection (Engine.IO Socket object). 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	fmt.Println(socket.Conn().Transport().Name()) // prints "polling" or "websocket"

	socket.Conn().Once("upgrade", func(...any) {
		fmt.Println(socket.Conn().Transport().Name()) // prints "websocket"
	})
})

func (*Socket) Connected 

func (s *Socket) Connected() bool

func (*Socket) Data 

func (s *Socket) Data() any

func (*Socket) Disconnect 

func (s *Socket) Disconnect(status bool) *Socket

Disconnects this client. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// disconnect this socket (the connection might be kept alive for other namespaces)
	socket.Disconnect(false)

	// disconnect this socket and close the underlying connection
	socket.Disconnect(true)
})

Param: bool - if `true`, closes the underlying connection
Return: *Socket

func (*Socket) Disconnected 

func (s *Socket) Disconnected() bool

Whether the socket is currently disconnected

func (*Socket) Emit 

func (s *Socket) Emit(ev string, args ...any) error

Emits to this client. 

io.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.Emit("hello", "world")

	// all serializable datastructures are supported (no need to call json.Marshal, But the map can only be of `map[string]any` type, currently does not support other types of maps)
	socket.Emit("hello", 1, "2", map[string]any{"3": []string{"4"}, "5": types.NewBytesBuffer([]byte{6})})

	// with an acknowledgement from the client
	socket.Emit("hello", "world", func(args ...any) {
		// ...
	})
})

func (*Socket) Except 

func (s *Socket) Except(room ...Room) *BroadcastOperator

Excludes a room when broadcasting. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
	// and this socket
	socket.Except("room-101").Emit("foo", "bar")

	// with an array of rooms
	socket.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

	// with multiple chained calls
	socket.Except("room-101").Except("room-102").Emit("foo", "bar")
})

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Socket) Handshake 

func (s *Socket) Handshake() *Handshake

func (*Socket) Id 

func (s *Socket) Id() SocketId

func (*Socket) In 

func (s *Socket) In(room ...Room) *BroadcastOperator

Targets a room when broadcasting. Similar to `to()`, but might feel clearer in some cases: 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// disconnect all clients in the "room-101" room, except this socket
	socket.In("room-101").DisconnectSockets(false)
});

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Socket) Join 

func (s *Socket) Join(rooms ...Room)

Joins a room. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// join a single room
	socket.Join("room1")

	// join multiple rooms
	socket.Join([]Room{"room-101", "room-102"}...)
})

Param: Room - a `Room`, or a `Room` slice to expand

func (*Socket) Leave 

func (s *Socket) Leave(room Room)

Leaves a room. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// leave a single room
	socket.Leave("room1")

	// leave multiple rooms
	socket.Leave("room-101")
	socket.Leave("room-102")
})

Param: Room - a `Room`, or a `Room` slice to expand

func (*Socket) ListenersAny 

func (s *Socket) ListenersAny() []events.Listener

Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, e.g. to remove listeners.

func (*Socket) ListenersAnyOutgoing 

func (s *Socket) ListenersAnyOutgoing() []events.Listener

Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, e.g. to remove listeners.

func (*Socket) Local 

func (s *Socket) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the “foo” event will be broadcast to all connected clients on this node, except this socket
	socket.Local().Emit("foo", "bar")
})

Return: a new *BroadcastOperator instance for chaining

func (*Socket) NotifyOutgoingListeners 

func (s *Socket) NotifyOutgoingListeners() func(*parser.Packet)

func (*Socket) Nsp 

func (s *Socket) Nsp() *Namespace

func (*Socket) OffAny 

func (s *Socket) OffAny(listener events.Listener) *Socket

Removes the listener that will be fired when any event is received. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	catchAllListener := func(events ...any) {
		fmt.Println(`got event `, events)
	}

	socket.OnAny(catchAllListener)

	// remove a specific listener
	socket.OffAny(catchAllListener)

	// or remove all listeners
	socket.OffAny(nil)
})

func (*Socket) OffAnyOutgoing 

func (s *Socket) OffAnyOutgoing(listener events.Listener) *Socket

Removes the listener that will be fired when any event is sent. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	catchAllListener := func(events ...any) {
		fmt.Println(`sent event `, events)
	}

	socket.OnAnyOutgoing(catchAllListener)

	// remove a specific listener
	socket.OffAnyOutgoing(catchAllListener)

	// or remove all listeners
	socket.OffAnyOutgoing(nil)
})

Param: events.Listener - the catch-all listener

func (*Socket) OnAny 

func (s *Socket) OnAny(listener events.Listener) *Socket

Adds a listener that will be fired when any event is received. The event name is passed as the first argument to the callback. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.OnAny(func(events ...any) {
		fmt.Println(`got event `, events)
	})
})

func (*Socket) OnAnyOutgoing 

func (s *Socket) OnAnyOutgoing(listener events.Listener) *Socket

Adds a listener that will be fired when any event is sent. The event name is passed as the first argument to the callback.

Note: acknowledgements sent to the client are not included. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.onAnyOutgoing(func(events ...any) {
		fmt.Println(`got event `, events)
	})
})

Param: events.Listener

func (*Socket) PrependAny 

func (s *Socket) PrependAny(listener events.Listener) *Socket

Adds a listener that will be fired when any event is received. The event name is passed as the first argument to the callback. The listener is added to the beginning of the listeners array.

func (*Socket) PrependAnyOutgoing 

func (s *Socket) PrependAnyOutgoing(listener events.Listener) *Socket

Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the callback. The listener is added to the beginning of the listeners array. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.PrependAnyOutgoing(func(events ...any) {
		fmt.Println(`sent event `, events)
	})
})

func (*Socket) Request 

func (s *Socket) Request() *types.HttpContext

A reference to the request that originated the underlying Engine.IO Socket.

func (*Socket) Rooms 

func (s *Socket) Rooms() *types.Set[Room]

Returns the rooms the socket is currently in. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	fmt.Println(socket.Rooms()) // *types.Set { <socket.id> }

	socket.Join("room1")

	fmt.Println(socket.Rooms()) // *types.Set { <socket.id>, "room1" }
})

func (*Socket) Send 

func (s *Socket) Send(args ...any) *Socket

Sends a `message` event.

This method mimics the WebSocket.send() method.

See: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Send("hello");

	// this is equivalent to
	socket.Emit("message", "hello");
});

func (*Socket) SetData 

func (s *Socket) SetData(data any)

func (*Socket) Timeout 

func (s *Socket) Timeout(timeout time.Duration) *Socket

Sets a modifier for a subsequent event emission that the callback will be called with an error when the given number of milliseconds have elapsed without an acknowledgement from the client: 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Timeout(1000 * time.Millisecond).Emit("my-event", func(args ...any) {
		if args[0] != nil {
			// the client did not acknowledge the event in the given delay
		}
	})
})

func (*Socket) To 

func (s *Socket) To(room ...Room) *BroadcastOperator

Targets a room when broadcasting. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the “foo” event will be broadcast to all connected clients in the “room-101” room, except this socket
	socket.To("room-101").Emit("foo", "bar")

	// the code above is equivalent to:
	io.To("room-101").Except(Room(socket.Id())).Emit("foo", "bar")

	// with an array of rooms (a client will be notified at most once)
	socket.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

	// with multiple chained calls
	socket.To("room-101").To("room-102").Emit("foo", "bar")
})

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Socket) Use 

func (s *Socket) Use(fn func([]any, func(error))) *Socket

Sets up socket middleware. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Use(func(append(events []any, next func(error)) {
		if isUnauthorized(events[0]) {
			next(error.New("unauthorized event"))
			return
		}
		// do not forget to call next
		next(nil)
	})

	socket.On("error", func(errs ...any) {
		if err, ok := errs[0].(error); ok && err.Error() == "unauthorized event" {
			socket.Disconnect(false)
		}
	});
});

func (*Socket) Volatile 

func (s *Socket) Volatile() *Socket

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Volatile().Emit("hello") // the client may or may not receive it
})

func (*Socket) Write 

func (s *Socket) Write(args ...any) *Socket

Sends a `message` event. Alias of Send.

type SocketDetails 

type SocketDetails interface {
	Id() SocketId
	Handshake() *Handshake
	Rooms() *types.Set[Room]
	Data() any
}

type SocketId 

type SocketId string

type StrictEventEmitter 

type StrictEventEmitter struct {
	events.EventEmitter
}

Strictly typed version of an `EventEmitter`. A `TypedEventEmitter` takes type parameters for mappings of event names to event data types, and strictly types method calls to the `EventEmitter` according to these event maps.

func NewStrictEventEmitter 

func NewStrictEventEmitter() *StrictEventEmitter

func (*StrictEventEmitter) Emit 

func (s *StrictEventEmitter) Emit(ev string, args ...any)

Emits an event.

func (*StrictEventEmitter) EmitReserved 

func (s *StrictEventEmitter) EmitReserved(ev string, args ...any)

Emits a reserved event.

This method is `protected`, so that only a class extending `StrictEventEmitter` can emit its own reserved events.

func (*StrictEventEmitter) EmitUntyped 

func (s *StrictEventEmitter) EmitUntyped(ev string, args ...any)

Emits an event.

This method is `protected`, so that only a class extending `StrictEventEmitter` can get around the strict typing. This is useful for calling `emit.apply`, which can be called as `emitUntyped.apply`.

func (*StrictEventEmitter) Listeners 

func (s *StrictEventEmitter) Listeners(ev string) []events.Listener

Returns the listeners listening to an event.

func (*StrictEventEmitter) On 

func (s *StrictEventEmitter) On(ev string, listeners ...events.Listener) error

Adds the `listener` function as an event listener for `ev`.

func (*StrictEventEmitter) Once 

func (s *StrictEventEmitter) Once(ev string, listeners ...events.Listener) error

type WriteOptions 

type WriteOptions struct {
	packet.Options

	Volatile     bool
	PreEncoded   bool
	WsPreEncoded string
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.