Class ParentNamespace

packages/socket.io/lib/parent-namespace.ts:30–109

 *
 */
export class ParentNamespace<
  ListenEvents extends EventsMap = DefaultEventsMap,
  EmitEvents extends EventsMap = ListenEvents,
  ServerSideEvents extends EventsMap = DefaultEventsMap,
  SocketData = any,
> extends Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData> {
  private static count: number = 0;
  private readonly children: Set<
    Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
  > = new Set();

  constructor(
    server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
  ) {
    super(server, "/_" + ParentNamespace.count++);
  }

  /**
   * @private
   */
  _initAdapter(): void {
    this.adapter = new ParentBroadcastAdapter(this);
  }

  public emit<Ev extends EventNamesWithoutAck<EmitEvents>>(
    ev: Ev,
    ...args: EventParams<EmitEvents, Ev>
  ): boolean {
    this.children.forEach((nsp) => {
      nsp.emit(ev, ...args);
    });

    return true;
  }

  createChild(
    name: string,
  ): Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData> {
    debug("creating child namespace %s", name);
    const namespace = new Namespace(this.server, name);
    this["_fns"].forEach((fn) => namespace.use(fn));
    this.listeners("connect").forEach((listener) =>
      namespace.on("connect", listener),
    );
    this.listeners("connection").forEach((listener) =>
      namespace.on("connection", listener),
    );
    this.children.add(namespace);

    if (this.server._opts.cleanupEmptyChildNamespaces) {
      const remove = namespace._remove;

      namespace._remove = (socket) => {
        remove.call(namespace, socket);
        if (namespace.sockets.size === 0) {
          debug("closing child namespace %s", name);
          namespace.adapter.close();
          this.server._nsps.delete(namespace.name);