Create a new version of paste:

import qs from 'qs';
import axios, {AxiosResponse} from 'axios';
import checkResponse from './CheckResponse';

const CONTENT_TYPE_URL_ENCODED =
  'application/x-www-form-urlencoded;charset=UTF-8';
const defaultConfig = {
  // timeout: 30000, //100000,
  headers: {
    'content-type': CONTENT_TYPE_URL_ENCODED,
  },
  validateStatus: function (status) {
    return status < 600;
  },
};

const instance = axios.create(defaultConfig);

// Sends a GET request to the specified URL with the specified options
async function get(url: string, {signal}) {
  return sendRequest('get', url, {signal});
}

// Sends a POST request to the specified URL with the specified params and options
async function post(url: any, params: any, options: any = {}) {
  // Set the default value for the options.headers object
  options.headers = options.headers || {};
  console.log('Header is ===================>', options);
  // Set the content-type header to the specified value, or the default value if not specified
  options.headers['content-type'] =
    options.headers['content-type'] || CONTENT_TYPE_URL_ENCODED;
  return sendRequest('post', url, params, {...options});
}

// Sends a PATCH request to the specified URL with the specified params
async function patch(url: any, params: any) {
  return sendRequest('patch', url, params);
}

// Sends a PUT request to the specified URL with the specified params
async function put(url: any, params: any) {
  sendRequest('put', url, params);
}

// Sends a DELETE request to the specified URL
async function Delete(url: any) {
  return sendRequest('delete', url);
}

// Sends a request to the specified URL using the specified method and options
async function sendRequest(
  method: string,
  url: any,
  params: any = {},
  options: any = {},
) {
  // Create a cancel token and a timer to cancel the request if it takes too long
  const source = axios.CancelToken.source();
  const timer = setTimeout(() => {
    source.cancel();
  }, 60 * 1000);
  // Set the cancel token as an option for the request
  options.cancelToken = source.token;
  // Send the request using the specified method, URL, params, and options
  console.log('===============>', options);

  const response = await instance[method](url, params, options);
  // Clear the timer
  clearTimeout(timer);
  // Return the response
  return response;
}

export function errorInterceptor(): string | void {
  instance.interceptors.response.use(undefined, error => {
    const {response} = error;

    if (!response) {
      // network error
      console.error(error);
      return;
    }

    if ([401, 403].includes(response.status)) {
      // auto logout if 401 or 403 response returned from api
      // accountService.logout();
    }

    // const errorMessage = response.data;
    // console.log('errorMessage', errorMessage)
    return response;
  });
}

/**
 * @param {object} data json object that contains key value for request to server
 * This will take data as JSON Object and return in Form of json Object and encode the url
 * @returns {object} This function will return object that hold url encoded data
 */
export const getFormDataObjForUrlEn = data => {
  const formData = Object.keys(data)
    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
    .join('&');
  return formData;
};

const methodMap = {
  GET: get,
  POST: post,
  PATCH: patch,
  PUT: put,
  DELETE: Delete,
};

export async function send(params: {
  method: string;
  url: string;
  obj?: any;
  isRawData?: boolean;
  contentType?: any;
  signal?: any;
}): Promise<any> {
  // Validate the input params
  validateParams(params);

  // Get the appropriate function for the specified HTTP method
  const func = getMethodFunc(params.method);

  // Send the request and handle the response/error
  let result = await request(func, params);

  // checkResponse({
  //   res: result,
  //   successCodes: [200, 201],
  // });
  //if (result.status === 200 || result.status === 201) {
  return result;
  //}
}

function validateParams(params: any) {
  if (!params || typeof params !== 'object') {
    throw new Error('params is undefined or not an object');
  }
}

function getMethodFunc(method: string) {
  const func = methodMap[method];
  if (!func) {
    throw new Error(`Invalid HTTP method: ${method}`);
  }
  return func;
}

async function request(func: any, params: any) {
  console.log('request =============>', params.contentType);
  try {
    let result;
    if (params.method === 'GET') {
      result = await func(params.url, {signal: params.signal});
    } else {
      let obj = params.obj;
      if (params.method === 'POST' && !params.isRawData) {
        obj = qs.stringify(obj);
      }
      const options = {
        headers: {
          'content-type': params.contentType || '',
        },
      };
      result = await func(params.url, obj, options);
    }
    console.log('------', result);
    return result;
  } catch (error) {
    //const err = errorInterceptor();
    throw error;
  }
}