import { Socket } from "./socket"; import type { Server } from "./index"; import { EventParams, EventNames, EventsMap, StrictEventEmitter, DefaultEventsMap, DecorateAcknowledgementsWithTimeoutAndMultipleResponses, AllButLast, Last, DecorateAcknowledgementsWithMultipleResponses, DecorateAcknowledgements, RemoveAcknowledgements, EventNamesWithAck, FirstNonErrorArg, EventNamesWithoutAck } from "./typed-events"; import type { Client } from "./client"; import type { Adapter, Room, SocketId } from "socket.io-adapter"; import { BroadcastOperator } from "./broadcast-operator"; export interface ExtendedError extends Error { data?: any; } export interface NamespaceReservedEventsMap { connect: (socket: Socket) => void; connection: (socket: Socket) => void; } export interface ServerReservedEventsMap extends NamespaceReservedEventsMap { new_namespace: (namespace: Namespace) => void; } export declare const RESERVED_EVENTS: ReadonlySet; /** * 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", (socket) => { * socket.on("order:list", () => {}); * socket.on("order:create", () => {}); * }); * * io.of("/users").on("connection", (socket) => { * socket.on("user:list", () => {}); * }); * ``` * * - rooms * * ``` * const orderNamespace = io.of("/orders"); * * orderNamespace.on("connection", (socket) => { * socket.join("room1"); * orderNamespace.to("room1").emit("hello"); * }); * * const userNamespace = io.of("/users"); * * userNamespace.on("connection", (socket) => { * socket.join("room1"); // distinct from the room in the "orders" namespace * userNamespace.to("room1").emit("holà"); * }); * ``` * * - middlewares * * ``` * const orderNamespace = io.of("/orders"); * * orderNamespace.use((socket, next) => { * // ensure the socket has access to the "orders" namespace * }); * * const userNamespace = io.of("/users"); * * userNamespace.use((socket, next) => { * // ensure the socket has access to the "users" namespace * }); * ``` */ export declare class Namespace extends StrictEventEmitter, NamespaceReservedEventsMap> { readonly name: string; readonly sockets: Map>; adapter: Adapter; /** @private */ readonly server: Server; /** @private */ _fns: Array<(socket: Socket, next: (err?: ExtendedError) => void) => void>; /** @private */ _ids: number; /** * Namespace constructor. * * @param server instance * @param name */ constructor(server: Server, name: string); /** * Initializes the `Adapter` for this nsp. * Run upon changing adapter by `Server#adapter` * in addition to the constructor. * * @private */ _initAdapter(): void; /** * Registers a middleware, which is a function that gets executed for every incoming {@link Socket}. * * @example * const myNamespace = io.of("/my-namespace"); * * myNamespace.use((socket, next) => { * // ... * next(); * }); * * @param fn - the middleware function */ use(fn: (socket: Socket, next: (err?: ExtendedError) => void) => void): this; /** * Executes the middleware for an incoming client. * * @param socket - the socket that will get added * @param fn - last fn call in the middleware * @private */ private run; /** * Targets a room when emitting. * * @example * const 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"); * * // with multiple chained calls * myNamespace.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, SocketData>; /** * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases: * * @example * const myNamespace = io.of("/my-namespace"); * * // disconnect all clients in the "room-101" room * myNamespace.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, SocketData>; /** * Excludes a room when emitting. * * @example * const 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"); * * // with multiple chained calls * myNamespace.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, SocketData>; /** * Adds a new client. * * @return {Socket} * @private */ _add(client: Client, auth: Record, fn: (socket: Socket) => void): any; private _createSocket; private _doConnect; /** * Removes a client. Called by each `Socket`. * * @private */ _remove(socket: Socket): void; /** * Emits to all connected clients. * * @example * const myNamespace = io.of("/my-namespace"); * * myNamespace.emit("hello", "world"); * * // all serializable datastructures are supported (no need to call JSON.stringify) * myNamespace.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) }); * * // with an acknowledgement from the clients * myNamespace.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: Ev, ...args: EventParams): boolean; /** * 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 * * @example * const myNamespace = io.of("/my-namespace"); * * myNamespace.send("hello"); * * // this is equivalent to * myNamespace.emit("message", "hello"); * * @return self */ send(...args: EventParams): this; /** * Sends a `message` event to all clients. Sends a `message` event. Alias of {@link send}. * * @return self */ write(...args: EventParams): this; /** * Sends a message to the other Socket.IO servers of the cluster. * * @example * const myNamespace = io.of("/my-namespace"); * * myNamespace.serverSideEmit("hello", "world"); * * myNamespace.on("hello", (arg1) => { * console.log(arg1); // prints "world" * }); * * // acknowledgements (without binary content) are supported too: * myNamespace.serverSideEmit("ping", (err, responses) => { * if (err) { * // some servers did not acknowledge the event in the given delay * } else { * console.log(responses); // one response per server (except the current one) * } * }); * * myNamespace.on("ping", (cb) => { * cb("pong"); * }); * * @param ev - the event name * @param args - an array of arguments, which may include an acknowledgement callback at the end */ serverSideEmit>(ev: Ev, ...args: EventParams, Ev>): boolean; /** * Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster. * * @example * const myNamespace = io.of("/my-namespace"); * * try { * const responses = await myNamespace.serverSideEmitWithAck("ping"); * console.log(responses); // one response per server (except the current one) * } catch (e) { * // some servers did not acknowledge the event in the given delay * } * * @param ev - the event name * @param args - an array of arguments * * @return a Promise that will be fulfilled when all servers have acknowledged the event */ serverSideEmitWithAck>(ev: Ev, ...args: AllButLast>): Promise>>[]>; /** * Called when a packet is received from another Socket.IO server * * @param args - an array of arguments, which may include an acknowledgement callback at the end * * @private */ _onServerSideEmit(args: [string, ...any[]]): void; /** * Gets a list of clients. * * @deprecated this method will be removed in the next major release, please use {@link Namespace#serverSideEmit} or * {@link Namespace#fetchSockets} instead. */ allSockets(): Promise>; /** * Sets the compress flag. * * @example * const myNamespace = io.of("/my-namespace"); * * myNamespace.compress(false).emit("hello"); * * @param compress - if `true`, compresses the sending data * @return self */ compress(compress: boolean): BroadcastOperator, 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 * const myNamespace = io.of("/my-namespace"); * * myNamespace.volatile.emit("hello"); // the clients may or may not receive it * * @return self */ get volatile(): BroadcastOperator, SocketData>; /** * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. * * @example * const myNamespace = io.of("/my-namespace"); * * // the “foo” event will be broadcast to all connected clients on this node * myNamespace.local.emit("foo", "bar"); * * @return a new {@link BroadcastOperator} instance for chaining */ get local(): BroadcastOperator, SocketData>; /** * Adds a timeout in milliseconds for the next operation. * * @example * const myNamespace = io.of("/my-namespace"); * * myNamespace.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>, SocketData>; /** * Returns the matching socket instances. * * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}. * * @example * const myNamespace = io.of("/my-namespace"); * * // return all Socket instances * const sockets = await myNamespace.fetchSockets(); * * // return all Socket instances in the "room1" room * const sockets = await myNamespace.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[]>; /** * 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 * const myNamespace = io.of("/my-namespace"); * * // make all socket instances join the "room1" room * myNamespace.socketsJoin("room1"); * * // make all socket instances in the "room1" room join the "room2" and "room3" rooms * myNamespace.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 * const myNamespace = io.of("/my-namespace"); * * // make all socket instances leave the "room1" room * myNamespace.socketsLeave("room1"); * * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms * myNamespace.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 * const myNamespace = io.of("/my-namespace"); * * // make all socket instances disconnect (the connections might be kept alive for other namespaces) * myNamespace.disconnectSockets(); * * // make all socket instances in the "room1" room disconnect and close the underlying connections * myNamespace.in("room1").disconnectSockets(true); * * @param close - whether to close the underlying connection */ disconnectSockets(close?: boolean): void; }