Method send

src/rpc.ts:708–763

(msg: any)

  // Serializes and sends a message. Returns the byte length reported by the transport, or
  // undefined if the transport doesn't report size.
  private send(msg: any): number | undefined {
    if (this.abortReason !== undefined) {
      // Ignore sends after we've aborted.
      return 0;
    }

    if (this.encodingLevel === "string") {
      let msgText: string;
      try {
        msgText = JSON.stringify(msg);
      } catch (err) {
        // If JSON stringification failed, there's something wrong with the devaluator, as it
        // should not allow non-JSONable values to be injected in the first place.
        try { this.abort(err); } catch (err2) {}
        throw err;
      }

      try {
        let sent = (this.transport as RpcTransport).send(msgText) as Promise<void> | undefined;
        if (sent !== undefined && typeof sent.catch === "function") {
          // If send fails, abort the connection, but don't try to send an abort message since
          // that'll probably also fail.
          sent.catch(err => this.abort(err, false));
        }
      } catch (err) {
        // The transport threw synchronously. Treat it like an async send failure: abort the
        // session (without trying to send an abort message over the broken transport), but
        // defer to a microtask so the caller finishes its own bookkeeping first, matching the
        // timing of a rejected promise from an async transport.
        queueMicrotask(() => this.abort(err, false));
      }
      return msgText.length;
    } else {
      // Custom encoding transport encodes and returns the actual encoded size, or void if size
      // is unavailable (e.g. structured clone).
      try {
        let size = (this.transport as RpcTransportWithCustomEncoding).send(msg);
        if (typeof size === "number") {
          return size;
        }
        // Defend against transports that return something other than a number, e.g. an
        // accidentally-async `send()` returning a promise: treat the size as unknown, and
        // observe any returned thenable so a rejection aborts the session rather than going
        // unhandled. (The documented contract is to report errors via `receive()`.)
        let thenable = size as unknown;
        if (thenable && typeof (thenable as PromiseLike<unknown>).then === "function") {
          Promise.resolve(thenable).catch(err => this.abort(err, false));
        }
        return undefined;
      } catch (err) {
        // Same as the synchronous failure case above.
        queueMicrotask(() => this.abort(err, false));
        return undefined;
      }
    }
  }

  sendCall(id: ImportId, path: PropertyPath, args?: RpcPayload): RpcImportHook {