Reqwest

import reqwest from "reqwest";

const reqwest = require("reqwest");

<script src="reqwest.js"></script>
<!-- reqwest is available as global variable -->

// Simple GET request
reqwest('path/to/data.json', function(resp) {
  console.log(resp);
});

// POST request with data
reqwest({
  url: 'path/to/api',
  method: 'post',
  data: { name: 'John', age: 30 },
  success: function(resp) {
    console.log('Success:', resp);
  },
  error: function(err) {
    console.log('Error:', err);
  }
});

// Using promises
reqwest({
  url: 'path/to/data.json',
  type: 'json'
})
.then(function(resp) {
  console.log('Data:', resp);
})
.catch(function(err) {
  console.log('Error:', err);
});

npm install reqwest xhr2

const reqwest = require('reqwest');

// Works the same as in browser environments
reqwest({
  url: 'https://api.example.com/data',
  type: 'json'
})
.then(function(data) {
  console.log('Data:', data);
})
.catch(function(err) {
  console.error('Error:', err);
});

/**
 * Creates and executes an AJAX request
 * @param {string|Object} options - URL string or configuration object
 * @param {Function} callback - Optional success callback
 * @returns {Object} Request object with promise-like interface
 */
function reqwest(options, callback);

interface RequestOptions {
  url: string;
  method?: string; // Default: 'GET'
  type?: string; // 'json' | 'xml' | 'html' | 'text' | 'js' | 'jsonp'
  data?: any; // Request data (object, string, FormData)
  headers?: Object; // Custom headers
  contentType?: string; // Request content type
  timeout?: number; // Request timeout in milliseconds
  async?: boolean; // Asynchronous flag (default: true)
  processData?: boolean; // Whether to process data (default: true)
  crossOrigin?: boolean; // Enable cross-origin requests
  withCredentials?: boolean; // Include credentials in cross-origin requests
  success?: Function; // Success callback
  error?: Function; // Error callback
  complete?: Function; // Always-called completion callback
  before?: Function; // Pre-request callback with XHR object
  jsonpCallback?: string; // JSONP callback parameter name
  jsonpCallbackName?: string; // Specific JSONP callback function name
  xhr?: Function; // Custom XHR factory function
  dataFilter?: Function; // Response filtering function
}

interface RequestPromise {
  then(success?: Function, fail?: Function): RequestPromise;
  fail(fn: Function): RequestPromise;
  always(fn: Function): RequestPromise;
  catch(fn: Function): RequestPromise;
  abort(): RequestPromise;
  retry(): RequestPromise;
}

/**
 * Serializes form elements to various formats
 * @param {Element|NodeList} elements - Form elements to serialize
 * @param {Object} options - Serialization options
 * @returns {string|Object|Array} Serialized data
 */
reqwest.serialize(elements, options);

/**
 * Serializes form elements to array of name/value pairs
 * @param {Element|NodeList} elements - Form elements
 * @returns {Array} Array of {name, value} objects
 */
reqwest.serializeArray(elements);

/**
 * Converts object to URL query string
 * @param {Object} object - Data to serialize
 * @param {boolean} traditional - Use traditional array serialization
 * @returns {string} Query string
 */
reqwest.toQueryString(object, traditional);

/**
 * Gets the JSONP callback prefix used for generating callback names
 * @returns {string} Callback prefix string
 */
reqwest.getcallbackPrefix();

/**
 * Sets global default options for all requests
 * @param {Object} options - Global configuration options
 */
reqwest.ajaxSetup(options);

/**
 * jQuery/Zepto compatibility layer
 * @param {Object} options - jQuery-style options
 * @param {Function} callback - Optional success callback
 * @returns {Object} Request object
 */
reqwest.compat(options, callback);

/**
 * Callback function for successful requests
 * @param {any} response - Parsed response data (JSON, XML, HTML, text, etc.)
 */
type SuccessCallback = (response: any) => void;

/**
 * Callback function for failed requests
 * @param {XMLHttpRequest} xhr - XMLHttpRequest object that failed
 * @param {string} message - Error message ('Request is aborted: timeout', etc.)
 * @param {any} error - Additional error context (parsing errors, etc.)
 */
type ErrorCallback = (xhr: XMLHttpRequest, message: string, error: any) => void;

/**
 * Callback function always called on completion
 * @param {any} response - Response data (same as success) or XMLHttpRequest object (on error)
 */
type CompleteCallback = (response: any) => void;

/**
 * Pre-request callback function
 * @param {XMLHttpRequest} xhr - XMLHttpRequest object before sending
 */
type BeforeCallback = (xhr: XMLHttpRequest) => void;

/**
 * Response filtering function
 * @param {any} data - Raw response data
 * @param {string} type - Response type
 * @returns {any} Filtered response data
 */
type DataFilter = (data: any, type: string) => any;