Method open

packages/socket.io-client/lib/manager.ts:318–376

* Sets the current transport `socket`. * * @param {Function} fn - optional, callback * @return self * @public

(fn?: (err?: Error) => void)

   * @public
   */
  public open(fn?: (err?: Error) => void): this {
    debug(class="st">"readyState %s", this._readyState);
    if (~this._readyState.indexOf(class="st">"open")) return this;

    debug(class="st">"opening %s", this.uri);
    this.engine = new Engine(this.uri, this.opts);
    const socket = this.engine;
    const self = this;
    this._readyState = class="st">"opening";
    this.skipReconnect = false;

    class="cm">// emit `open`
    const openSubDestroy = on(socket, class="st">"open", function () {
      self.onopen();
      fn && fn();
    });

    const onError = (err) => {
      debug(class="st">"error");
      this.cleanup();
      this._readyState = class="st">"closed";
      this.emitReserved(class="st">"error", err);
      if (fn) {
        fn(err);
      } else {
        class="cm">// Only do this if there is no fn to handle the error
        this.maybeReconnectOnOpen();
      }
    };

    class="cm">// emit `error`
    const errorSub = on(socket, class="st">"error", onError);

    if (false !== this._timeout) {
      const timeout = this._timeout;
      debug(class="st">"connect attempt will timeout after %d", timeout);

      class="cm">// set timer
      const timer = this.setTimeoutFn(() => {
        debug(class="st">"connect attempt timed out after %d", timeout);
        openSubDestroy();
        onError(new Error(class="st">"timeout"));
        socket.close();
      }, timeout);

      if (this.opts.autoUnref) {
        timer.unref();
      }

      this.subs.push(() => {
        this.clearTimeoutFn(timer);
      });
    }

    this.subs.push(openSubDestroy);
    this.subs.push(errorSub);

    return this;