321 lines
8.6 KiB
TypeScript
321 lines
8.6 KiB
TypeScript
// import type { BroadcastFlags, Room, SocketId } from "socket.io-adapter"
|
||
import type { BroadcastFlags, Room, SocketId } from "../socket.io-adapter"
|
||
import { Handshake, RESERVED_EVENTS, Socket } from "./socket"
|
||
// import { PacketType } from "socket.io-parser"
|
||
import { PacketType } from "../socket.io-parser"
|
||
// import type { Adapter } from "socket.io-adapter"
|
||
import type { Adapter } from "../socket.io-adapter"
|
||
import type {
|
||
EventParams,
|
||
EventNames,
|
||
EventsMap,
|
||
TypedEventBroadcaster,
|
||
} from "./typed-events"
|
||
|
||
export class BroadcastOperator<EmitEvents extends EventsMap>
|
||
implements TypedEventBroadcaster<EmitEvents>
|
||
{
|
||
constructor(
|
||
private readonly adapter: Adapter,
|
||
private readonly rooms: Set<Room> = new Set<Room>(),
|
||
private readonly exceptRooms: Set<Room> = new Set<Room>(),
|
||
private readonly flags: BroadcastFlags = {}
|
||
) { }
|
||
|
||
/**
|
||
* Targets a room when emitting.
|
||
*
|
||
* @param room
|
||
* @return a new BroadcastOperator instance
|
||
* @public
|
||
*/
|
||
public to(room: Room | Room[]): BroadcastOperator<EmitEvents> {
|
||
const rooms = new Set(this.rooms)
|
||
if (Array.isArray(room)) {
|
||
room.forEach((r) => rooms.add(r))
|
||
} else {
|
||
rooms.add(room)
|
||
}
|
||
return new BroadcastOperator(
|
||
this.adapter,
|
||
rooms,
|
||
this.exceptRooms,
|
||
this.flags
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Targets a room when emitting.
|
||
*
|
||
* @param room
|
||
* @return a new BroadcastOperator instance
|
||
* @public
|
||
*/
|
||
public in(room: Room | Room[]): BroadcastOperator<EmitEvents> {
|
||
return this.to(room)
|
||
}
|
||
|
||
/**
|
||
* Excludes a room when emitting.
|
||
*
|
||
* @param room
|
||
* @return a new BroadcastOperator instance
|
||
* @public
|
||
*/
|
||
public except(room: Room | Room[]): BroadcastOperator<EmitEvents> {
|
||
const exceptRooms = new Set(this.exceptRooms)
|
||
if (Array.isArray(room)) {
|
||
room.forEach((r) => exceptRooms.add(r))
|
||
} else {
|
||
exceptRooms.add(room)
|
||
}
|
||
return new BroadcastOperator(
|
||
this.adapter,
|
||
this.rooms,
|
||
exceptRooms,
|
||
this.flags
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Sets the compress flag.
|
||
*
|
||
* @param compress - if `true`, compresses the sending data
|
||
* @return a new BroadcastOperator instance
|
||
* @public
|
||
*/
|
||
public compress(compress: boolean): BroadcastOperator<EmitEvents> {
|
||
const flags = Object.assign({}, this.flags, { compress })
|
||
return new BroadcastOperator(
|
||
this.adapter,
|
||
this.rooms,
|
||
this.exceptRooms,
|
||
flags
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 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).
|
||
*
|
||
* @return a new BroadcastOperator instance
|
||
* @public
|
||
*/
|
||
public get volatile(): BroadcastOperator<EmitEvents> {
|
||
const flags = Object.assign({}, this.flags, { volatile: true })
|
||
return new BroadcastOperator(
|
||
this.adapter,
|
||
this.rooms,
|
||
this.exceptRooms,
|
||
flags
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
|
||
*
|
||
* @return a new BroadcastOperator instance
|
||
* @public
|
||
*/
|
||
public get local(): BroadcastOperator<EmitEvents> {
|
||
const flags = Object.assign({}, this.flags, { local: true })
|
||
return new BroadcastOperator(
|
||
this.adapter,
|
||
this.rooms,
|
||
this.exceptRooms,
|
||
flags
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Emits to all clients.
|
||
*
|
||
* @return Always true
|
||
* @public
|
||
*/
|
||
public emit<Ev extends EventNames<EmitEvents>>(
|
||
ev: Ev,
|
||
...args: EventParams<EmitEvents, Ev>
|
||
): boolean {
|
||
if (RESERVED_EVENTS.has(ev)) {
|
||
throw new Error(`"${ev}" is a reserved event name`)
|
||
}
|
||
// set up packet object
|
||
const data = [ev, ...args]
|
||
const packet = {
|
||
type: PacketType.EVENT,
|
||
data: data,
|
||
}
|
||
|
||
if ("function" == typeof data[data.length - 1]) {
|
||
throw new Error("Callbacks are not supported when broadcasting")
|
||
}
|
||
|
||
this.adapter.broadcast(packet, {
|
||
rooms: this.rooms,
|
||
except: this.exceptRooms,
|
||
flags: this.flags,
|
||
})
|
||
|
||
return true
|
||
}
|
||
|
||
/**
|
||
* Gets a list of clients.
|
||
*
|
||
* @public
|
||
*/
|
||
public allSockets(): Promise<Set<SocketId>> {
|
||
if (!this.adapter) {
|
||
throw new Error(
|
||
"No adapter for this namespace, are you trying to get the list of clients of a dynamic namespace?"
|
||
)
|
||
}
|
||
return this.adapter.sockets(this.rooms)
|
||
}
|
||
|
||
/**
|
||
* Returns the matching socket instances
|
||
*
|
||
* @public
|
||
*/
|
||
public fetchSockets(): Promise<RemoteSocket<EmitEvents>[]> {
|
||
return this.adapter
|
||
.fetchSockets({
|
||
rooms: this.rooms,
|
||
except: this.exceptRooms,
|
||
})
|
||
.then((sockets) => {
|
||
return sockets.map((socket) => {
|
||
if (socket instanceof Socket) {
|
||
// FIXME the TypeScript compiler complains about missing private properties
|
||
return socket as unknown as RemoteSocket<EmitEvents>
|
||
} else {
|
||
return new RemoteSocket(this.adapter, socket as SocketDetails)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Makes the matching socket instances join the specified rooms
|
||
*
|
||
* @param room
|
||
* @public
|
||
*/
|
||
public socketsJoin(room: Room | Room[]): void {
|
||
this.adapter.addSockets(
|
||
{
|
||
rooms: this.rooms,
|
||
except: this.exceptRooms,
|
||
},
|
||
Array.isArray(room) ? room : [room]
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Makes the matching socket instances leave the specified rooms
|
||
*
|
||
* @param room
|
||
* @public
|
||
*/
|
||
public socketsLeave(room: Room | Room[]): void {
|
||
this.adapter.delSockets(
|
||
{
|
||
rooms: this.rooms,
|
||
except: this.exceptRooms,
|
||
},
|
||
Array.isArray(room) ? room : [room]
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Makes the matching socket instances disconnect
|
||
*
|
||
* @param close - whether to close the underlying connection
|
||
* @public
|
||
*/
|
||
public disconnectSockets(close: boolean = false): void {
|
||
this.adapter.disconnectSockets(
|
||
{
|
||
rooms: this.rooms,
|
||
except: this.exceptRooms,
|
||
},
|
||
close
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Format of the data when the Socket instance exists on another Socket.IO server
|
||
*/
|
||
interface SocketDetails {
|
||
id: SocketId
|
||
handshake: Handshake
|
||
rooms: Room[]
|
||
data: any
|
||
}
|
||
|
||
/**
|
||
* Expose of subset of the attributes and methods of the Socket class
|
||
*/
|
||
export class RemoteSocket<EmitEvents extends EventsMap>
|
||
implements TypedEventBroadcaster<EmitEvents>
|
||
{
|
||
public readonly id: SocketId
|
||
public readonly handshake: Handshake
|
||
public readonly rooms: Set<Room>
|
||
public readonly data: any
|
||
|
||
private readonly operator: BroadcastOperator<EmitEvents>
|
||
|
||
constructor(adapter: Adapter, details: SocketDetails) {
|
||
this.id = details.id
|
||
this.handshake = details.handshake
|
||
this.rooms = new Set(details.rooms)
|
||
this.data = details.data
|
||
this.operator = new BroadcastOperator(adapter, new Set([this.id]))
|
||
}
|
||
|
||
public emit<Ev extends EventNames<EmitEvents>>(
|
||
ev: Ev,
|
||
...args: EventParams<EmitEvents, Ev>
|
||
): boolean {
|
||
return this.operator.emit(ev, ...args)
|
||
}
|
||
|
||
/**
|
||
* Joins a room.
|
||
*
|
||
* @param {String|Array} room - room or array of rooms
|
||
* @public
|
||
*/
|
||
public join(room: Room | Room[]): void {
|
||
return this.operator.socketsJoin(room)
|
||
}
|
||
|
||
/**
|
||
* Leaves a room.
|
||
*
|
||
* @param {String} room
|
||
* @public
|
||
*/
|
||
public leave(room: Room): void {
|
||
return this.operator.socketsLeave(room)
|
||
}
|
||
|
||
/**
|
||
* Disconnects this client.
|
||
*
|
||
* @param {Boolean} close - if `true`, closes the underlying connection
|
||
* @return {Socket} self
|
||
*
|
||
* @public
|
||
*/
|
||
public disconnect(close = false): this {
|
||
this.operator.disconnectSockets(close)
|
||
return this
|
||
}
|
||
}
|