react-native-xenon/lib/module/interceptors/FetchInterceptor.js

A powerful in-app debugging tool for React Native.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _constants = require("../core/constants");
var _utils = require("../core/utils");
var _types = require("../types");
var _HttpInterceptor = _interopRequireDefault(require("./HttpInterceptor"));
var _class, _class2;
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _applyDecoratedDescriptor(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }
const originalFetch = global.fetch;
let FetchInterceptor = exports.default = (0, _utils.singleton)(_class = (_class2 = class FetchInterceptor extends _HttpInterceptor.default {
  enableInterception() {
    if (this.isInterceptorEnabled) return;
    const {
      openCallback,
      requestHeaderCallback,
      sendCallback,
      headerReceivedCallback,
      responseCallback
    } = this.getCallbacks();
    global.fetch = async function (input, init) {
      const interceptionId = (0, _utils.getHttpInterceptorId)();
      const requestHeaders = new Headers(init?.headers);
      requestHeaders.append(_constants.NETWORK_REQUEST_HEADER, _types.NetworkType.Fetch);
      const requestInit = {
        ...init,
        headers: requestHeaders
      };

      //#region open
      const method = (0, _utils.formatRequestMethod)(init?.method);
      let url;
      switch (true) {
        case input instanceof Request:
          url = input.url;
          break;
        case input instanceof URL:
          url = input.href;
          break;
        default:
          url = input;
      }
      openCallback?.(interceptionId, _types.NetworkType.Fetch, method, url);
      //#endregion

      //#region requestHeader
      const headers = requestInit?.headers;
      if (headers) {
        switch (true) {
          case headers instanceof Headers:
            for (const [headerKey, headerValue] of headers.entries()) {
              requestHeaderCallback?.(interceptionId, headerKey, headerValue);
            }
            break;
          case Array.isArray(headers):
            for (const [headerKey, headerValue] of headers) {
              if (headerKey && headerValue) requestHeaderCallback?.(interceptionId, headerKey, headerValue);
            }
            break;
          default:
            for (const key in headers) {
              if (headers[key]) requestHeaderCallback?.(interceptionId, key, headers[key]);
            }
            break;
        }
      }
      //#endregion

      //#region send
      const startTime = Date.now();
      sendCallback?.(interceptionId, init?.body ?? null);
      //#endregion

      const response = await originalFetch.call(this, input, requestInit);
      const endTime = Date.now();
      const clonedResponse = response.clone();
      const clonedResponseHeaders = clonedResponse.headers;

      //#region headerReceived
      const contentTypeString = clonedResponseHeaders.get('Content-Type');
      const contentLengthString = clonedResponseHeaders.get('Content-Length');
      const responseContentType = contentTypeString ? contentTypeString.split(';')[0] : undefined;
      const responseSize = contentLengthString ? parseInt(contentLengthString, 10) : undefined;
      let responseHeaders = '';
      for (const [headerKey, headerValue] of clonedResponseHeaders.entries()) {
        responseHeaders += (0, _utils.keyValueToString)(headerKey, headerValue, responseHeaders.length ? 'leading' : null);
      }
      headerReceivedCallback?.(interceptionId, responseContentType, responseSize, responseHeaders);
      //#endregion

      //#region response
      const responseBody = await clonedResponse.text().catch(() => null);
      const duration = endTime - startTime;
      responseCallback?.(interceptionId, clonedResponse.status, 0, duration, responseBody, clonedResponse.url, clonedResponse.type);
      //#endregion

      return response;
    };
    this.isInterceptorEnabled = true;
  }
  disableInterception() {
    if (!this.isInterceptorEnabled) return;
    this.isInterceptorEnabled = false;
    global.fetch = originalFetch;
    this.clearCallbacks();
  }
}, _applyDecoratedDescriptor(_class2.prototype, "enableInterception", [_utils.frozen], Object.getOwnPropertyDescriptor(_class2.prototype, "enableInterception"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "disableInterception", [_utils.frozen], Object.getOwnPropertyDescriptor(_class2.prototype, "disableInterception"), _class2.prototype), _class2)) || _class;
//# sourceMappingURL=FetchInterceptor.js.map