async start()

in experimental/sdk/y-azure-webpubsub-client/src/WebPubSubSyncClient.ts [267:356]
74 lines of code
10 McCabe index (conditional complexity)

  async start() {
    if (this._wsConnected || this._ws) {
      return;
    }
    const client = this;

    const res = await fetch(this._url);
    const data = await res.json();

    const websocket = new WebSocket(data.url, AzureWebPubSubJsonProtocol);
    websocket.binaryType = "arraybuffer";
    client._ws = websocket;
    client._wsConnected = false;
    client.synced = false;

    websocket.onmessage = (event) => {
      if (event.data === null) {
        return;
      }

      const message: Message = JSON.parse(event.data.toString());
      if (message.type === MessageType.System) {
        // simply skip system event.
        return;
      }

      const messageData = message.data;
      if (messageData.t !== undefined && messageData.t !== client._uuid) {
        // should ignore message for other clients.
        return;
      }

      const buf = Buffer.from(messageData.c, "base64");
      client._wsLastMessageReceived = Date.now();
      const encoder = readMessage(client, buf, true);
      if (encoding.length(encoder) > 1) {
        sendToControlGroup(
          client,
          client.topic,
          MessageDataType.Sync,
          encoding.toUint8Array(encoder)
        );
      }
    };

    websocket.onclose = () => {
      client._ws = null;
      if (client._wsConnected) {
        client._wsConnected = false;
        client.synced = false;
        awarenessProtocol.removeAwarenessStates(
          client.awareness,
          Array.from(client.awareness.getStates().keys()).filter(
            (x) => x !== client.doc.clientID
          ),
          client
        );
      } else {
        // TODO reconnect
      }
    };

    websocket.onopen = () => {
      client._wsLastMessageReceived = Date.now();
      client._wsConnected = true;

      joinGroup(client, client.topic);

      // always send sync step 1 when connected
      const encoder = encoding.createEncoder();
      encoding.writeVarUint(encoder, messageSyncStep1);
      syncProtocol.writeSyncStep1(encoder, client.doc);
      const u8 = encoding.toUint8Array(encoder);
      sendToControlGroup(client, client.topic, MessageDataType.Init, u8);

      // broadcast awareness state
      if (client.awareness.getLocalState() !== null) {
        const encoderAwarenessState = encoding.createEncoder();
        encoding.writeVarUint(encoderAwarenessState, messageAwareness);
        encoding.writeVarUint8Array(
          encoderAwarenessState,
          awarenessProtocol.encodeAwarenessUpdate(client.awareness, [
            client.doc.clientID,
          ])
        );
        const u8 = encoding.toUint8Array(encoder);
        sendToControlGroup(client, client.topic, MessageDataType.Awareness, u8);
      }
    };
  }