|
|
|
|
import type { BroadcastFlags, Room, SocketId } from "socket.io-adapter";
|
|
|
|
|
import { Handshake } from "./socket";
|
|
|
|
|
import type { Adapter } from "socket.io-adapter";
|
|
|
|
|
import type { EventParams, EventNames, EventsMap, TypedEventBroadcaster, DecorateAcknowledgements, DecorateAcknowledgementsWithTimeoutAndMultipleResponses, AllButLast, Last, SecondArg } from "./typed-events";
|
|
|
|
|
export declare class BroadcastOperator<EmitEvents extends EventsMap, SocketData> implements TypedEventBroadcaster<EmitEvents> {
|
|
|
|
|
private readonly adapter;
|
|
|
|
|
private readonly rooms;
|
|
|
|
|
private readonly exceptRooms;
|
|
|
|
|
private readonly flags;
|
|
|
|
|
constructor(adapter: Adapter, rooms?: Set<Room>, exceptRooms?: Set<Room>, flags?: BroadcastFlags & {
|
|
|
|
|
expectSingleResponse?: boolean;
|
|
|
|
|
});
|
|
|
|
|
/**
|
|
|
|
|
* Targets a room when emitting.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // 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");
|
|
|
|
|
*
|
|
|
|
|
* // with multiple chained calls
|
|
|
|
|
* io.to("room-101").to("room-102").emit("foo", "bar");
|
|
|
|
|
*
|
|
|
|
|
* @param room - a room, or an array of rooms
|
|
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
|
|
*/
|
|
|
|
|
to(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // disconnect all clients in the "room-101" room
|
|
|
|
|
* io.in("room-101").disconnectSockets();
|
|
|
|
|
*
|
|
|
|
|
* @param room - a room, or an array of rooms
|
|
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
|
|
*/
|
|
|
|
|
in(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* Excludes a room when emitting.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // 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");
|
|
|
|
|
*
|
|
|
|
|
* // with multiple chained calls
|
|
|
|
|
* io.except("room-101").except("room-102").emit("foo", "bar");
|
|
|
|
|
*
|
|
|
|
|
* @param room - a room, or an array of rooms
|
|
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
|
|
*/
|
|
|
|
|
except(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* Sets the compress flag.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* io.compress(false).emit("hello");
|
|
|
|
|
*
|
|
|
|
|
* @param compress - if `true`, compresses the sending data
|
|
|
|
|
* @return a new BroadcastOperator instance
|
|
|
|
|
*/
|
|
|
|
|
compress(compress: boolean): BroadcastOperator<EmitEvents, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* 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).
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* io.volatile.emit("hello"); // the clients may or may not receive it
|
|
|
|
|
*
|
|
|
|
|
* @return a new BroadcastOperator instance
|
|
|
|
|
*/
|
|
|
|
|
get volatile(): BroadcastOperator<EmitEvents, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // the “foo” event will be broadcast to all connected clients on this node
|
|
|
|
|
* io.local.emit("foo", "bar");
|
|
|
|
|
*
|
|
|
|
|
* @return a new {@link BroadcastOperator} instance for chaining
|
|
|
|
|
*/
|
|
|
|
|
get local(): BroadcastOperator<EmitEvents, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* Adds a timeout in milliseconds for the next operation
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* io.timeout(1000).emit("some-event", (err, responses) => {
|
|
|
|
|
* if (err) {
|
|
|
|
|
* // some clients did not acknowledge the event in the given delay
|
|
|
|
|
* } else {
|
|
|
|
|
* console.log(responses); // one response per client
|
|
|
|
|
* }
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* @param timeout
|
|
|
|
|
*/
|
|
|
|
|
timeout(timeout: number): BroadcastOperator<DecorateAcknowledgementsWithTimeoutAndMultipleResponses<EmitEvents>, SocketData>;
|
|
|
|
|
/**
|
|
|
|
|
* Emits to all clients.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // 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).emit("some-event", (err, responses) => {
|
|
|
|
|
* if (err) {
|
|
|
|
|
* // some clients did not acknowledge the event in the given delay
|
|
|
|
|
* } else {
|
|
|
|
|
* console.log(responses); // one response per client
|
|
|
|
|
* }
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* @return Always true
|
|
|
|
|
*/
|
|
|
|
|
emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
|
|
|
|
|
/**
|
|
|
|
|
* Emits an event and waits for an acknowledgement from all clients.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* try {
|
|
|
|
|
* const responses = await io.timeout(1000).emitWithAck("some-event");
|
|
|
|
|
* console.log(responses); // one response per client
|
|
|
|
|
* } catch (e) {
|
|
|
|
|
* // some clients did not acknowledge the event in the given delay
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* @return a Promise that will be fulfilled when all clients have acknowledged the event
|
|
|
|
|
*/
|
|
|
|
|
emitWithAck<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: AllButLast<EventParams<EmitEvents, Ev>>): Promise<SecondArg<Last<EventParams<EmitEvents, Ev>>>>;
|
|
|
|
|
/**
|
|
|
|
|
* Gets a list of clients.
|
|
|
|
|
*
|
|
|
|
|
* @deprecated this method will be removed in the next major release, please use {@link Server#serverSideEmit} or
|
|
|
|
|
* {@link fetchSockets} instead.
|
|
|
|
|
*/
|
|
|
|
|
allSockets(): Promise<Set<SocketId>>;
|
|
|
|
|
/**
|
|
|
|
|
* 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 {@link Adapter}.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // return all Socket instances
|
|
|
|
|
* const sockets = await io.fetchSockets();
|
|
|
|
|
*
|
|
|
|
|
* // return all Socket instances in the "room1" room
|
|
|
|
|
* const sockets = await io.in("room1").fetchSockets();
|
|
|
|
|
*
|
|
|
|
|
* for (const socket of sockets) {
|
|
|
|
|
* console.log(socket.id);
|
|
|
|
|
* console.log(socket.handshake);
|
|
|
|
|
* console.log(socket.rooms);
|
|
|
|
|
* console.log(socket.data);
|
|
|
|
|
*
|
|
|
|
|
* socket.emit("hello");
|
|
|
|
|
* socket.join("room1");
|
|
|
|
|
* socket.leave("room2");
|
|
|
|
|
* socket.disconnect();
|
|
|
|
|
* }
|
|
|
|
|
*/
|
|
|
|
|
fetchSockets(): Promise<RemoteSocket<EmitEvents, SocketData>[]>;
|
|
|
|
|
/**
|
|
|
|
|
* 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 {@link Adapter}.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
*
|
|
|
|
|
* // 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(["room2", "room3"]);
|
|
|
|
|
*
|
|
|
|
|
* @param room - a room, or an array of rooms
|
|
|
|
|
*/
|
|
|
|
|
socketsJoin(room: Room | Room[]): void;
|
|
|
|
|
/**
|
|
|
|
|
* 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 {@link Adapter}.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // 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(["room2", "room3"]);
|
|
|
|
|
*
|
|
|
|
|
* @param room - a room, or an array of rooms
|
|
|
|
|
*/
|
|
|
|
|
socketsLeave(room: Room | Room[]): void;
|
|
|
|
|
/**
|
|
|
|
|
* Makes the matching socket instances disconnect.
|
|
|
|
|
*
|
|
|
|
|
* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* // make all socket instances disconnect (the connections might be kept alive for other namespaces)
|
|
|
|
|
* io.disconnectSockets();
|
|
|
|
|
*
|
|
|
|
|
* // make all socket instances in the "room1" room disconnect and close the underlying connections
|
|
|
|
|
* io.in("room1").disconnectSockets(true);
|
|
|
|
|
*
|
|
|
|
|
* @param close - whether to close the underlying connection
|
|
|
|
|
*/
|
|
|
|
|
disconnectSockets(close?: boolean): void;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Format of the data when the Socket instance exists on another Socket.IO server
|
|
|
|
|
*/
|
|
|
|
|
interface SocketDetails<SocketData> {
|
|
|
|
|
id: SocketId;
|
|
|
|
|
handshake: Handshake;
|
|
|
|
|
rooms: Room[];
|
|
|
|
|
data: SocketData;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Expose of subset of the attributes and methods of the Socket class
|
|
|
|
|
*/
|
|
|
|
|
export declare class RemoteSocket<EmitEvents extends EventsMap, SocketData> implements TypedEventBroadcaster<EmitEvents> {
|
|
|
|
|
readonly id: SocketId;
|
|
|
|
|
readonly handshake: Handshake;
|
|
|
|
|
readonly rooms: Set<Room>;
|
|
|
|
|
readonly data: SocketData;
|
|
|
|
|
private readonly operator;
|
|
|
|
|
constructor(adapter: Adapter, details: SocketDetails<SocketData>);
|
|
|
|
|
/**
|
|
|
|
|
* Adds a timeout in milliseconds for the next operation.
|
|
|
|
|
*
|
|
|
|
|
* @example
|
|
|
|
|
* const sockets = await io.fetchSockets();
|
|
|
|
|
*
|
|
|
|
|
* for (const socket of sockets) {
|
|
|
|
|
* if (someCondition) {
|
|
|
|
|
* socket.timeout(1000).emit("some-event", (err) => {
|
|
|
|
|
* if (err) {
|
|
|
|
|
* // the client did not acknowledge the event in the given delay
|
|
|
|
|
* }
|
|
|
|
|
* });
|
|
|
|
|
* }
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* // note: if possible, using a room instead of looping over all sockets is preferable
|
|
|
|
|
* io.timeout(1000).to(someConditionRoom).emit("some-event", (err, responses) => {
|
|
|
|
|
* // ...
|
|
|
|
|
* });
|
|
|
|
|
*
|
|
|
|
|
* @param timeout
|
|
|
|
|
*/
|
|
|
|
|
timeout(timeout: number): BroadcastOperator<DecorateAcknowledgements<EmitEvents>, SocketData>;
|
|
|
|
|
emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
|
|
|
|
|
/**
|
|
|
|
|
* Joins a room.
|
|
|
|
|
*
|
|
|
|
|
* @param {String|Array} room - room or array of rooms
|
|
|
|
|
*/
|
|
|
|
|
join(room: Room | Room[]): void;
|
|
|
|
|
/**
|
|
|
|
|
* Leaves a room.
|
|
|
|
|
*
|
|
|
|
|
* @param {String} room
|
|
|
|
|
*/
|
|
|
|
|
leave(room: Room): void;
|
|
|
|
|
/**
|
|
|
|
|
* Disconnects this client.
|
|
|
|
|
*
|
|
|
|
|
* @param {Boolean} close - if `true`, closes the underlying connection
|
|
|
|
|
* @return {Socket} self
|
|
|
|
|
*/
|
|
|
|
|
disconnect(close?: boolean): this;
|
|
|
|
|
}
|
|
|
|
|
export {};
|