private async sendRequest()

in src/components/operations/operation-details/ko/runtime/operation-console.ts [470:576]
89 lines of code
19 McCabe index (conditional complexity)

    private async sendRequest(): Promise<void> {
        this.requestError(null);
        this.sendingRequest(true);
        this.responseStatusCode(null);
        const consoleOperation = this.consoleOperation();
        const request = consoleOperation.request;
        const url = consoleOperation.requestUrl();
        const method = consoleOperation.method;
        const headers = [...request.headers()];

        let payload;

        switch (consoleOperation.request.bodyFormat()) {
            case RequestBodyType.raw:
                payload = request.body();
                break;

            case RequestBodyType.binary:
                payload = await Utils.readFileAsByteArray(request.binary());
                break;

            case RequestBodyType.form:
                payload = request.getFormDataPayload();
                break;

            default:
                throw new Error("Unknown body format.");
        }

        try {
            const request: HttpRequest = {
                url: url,
                method: method,
                headers: headers
                    .map(x => { return { name: x.name(), value: x.value() ?? "" }; })
                    .filter(x => !!x.name && !!x.value),
                body: payload
            };

            const response: HttpResponse = this.useCorsProxy()
                ? await this.sendFromProxy(request)
                : await this.sendFromBrowser(request);

            const headersString = response.headers.map(x => `${x.name}: ${x.value}`).join("\n");
            const contentTypeHeader = response.headers.find(x => x.name === KnownHttpHeaders.ContentType.toLowerCase());
            const responseContentType = contentTypeHeader?.value;

            this.responseHeadersString(headersString);

            const knownStatusCode = KnownStatusCodes.find(x => x.code === response.statusCode);

            const responseStatusText = response.statusText || knownStatusCode
                ? knownStatusCode?.description
                : "Unknown";

            this.responseStatusCode(response.statusCode.toString());
            this.responseStatusText(responseStatusText);

            if (responseContentType && downloadableTypes.some(type => responseContentType.includes(type))) {
                const blob = new Blob([response.body], { type: responseContentType });
                const fileExtension = getExtension(responseContentType);

                const fileName = fileExtension
                    ? consoleOperation.name + "." + fileExtension
                    : consoleOperation.name;

                saveAs(blob, fileName);
            } else {
                let responseBody: string;
                if(this.useCorsProxy()) {
                    const contentEncodingHeader = response.headers.find(x => x.name === KnownHttpHeaders.ContentEncoding.toLowerCase());
                    if (contentEncodingHeader?.value === "gzip") {
                        responseBody = await this.decompressBody(response.body);
                    } else {
                        responseBody = response.body.toString();
                    }
                } else {
                    responseBody = response.body.toString();
                }

                if (responseContentType && Utils.isJsonContentType(responseContentType)) {
                    this.responseBody(Utils.formatJson(responseBody));
                }
                else if (responseContentType && Utils.isXmlContentType(responseContentType)) {
                    this.responseBody(Utils.formatXml(responseBody));
                }
                else {
                    this.responseBody(responseBody);
                }
            }

            this.logSentRequest(this.api().name, consoleOperation.operationName, method, response.statusCode);
        }
        catch (error) {
            if (error instanceof RequestError) {
                this.requestError(error.message);
                this.logSentRequest(this.api().name, consoleOperation.operationName, method);
                return;
            }

            this.requestError(`Unable to complete request.`);
            this.logger.trackError(error);
        }
        finally {
            this.sendingRequest(false);
        }
    }