@wiajs/req 1.7.7

package/lib/helpers/HttpStatusCode.js

@@ -0,0 +1,69 @@
+const HttpStatusCode = {
+    Continue: 100,
+    SwitchingProtocols: 101,
+    Processing: 102,
+    EarlyHints: 103,
+    Ok: 200,
+    Created: 201,
+    Accepted: 202,
+    NonAuthoritativeInformation: 203,
+    NoContent: 204,
+    ResetContent: 205,
+    PartialContent: 206,
+    MultiStatus: 207,
+    AlreadyReported: 208,
+    ImUsed: 226,
+    MultipleChoices: 300,
+    MovedPermanently: 301,
+    Found: 302,
+    SeeOther: 303,
+    NotModified: 304,
+    UseProxy: 305,
+    Unused: 306,
+    TemporaryRedirect: 307,
+    PermanentRedirect: 308,
+    BadRequest: 400,
+    Unauthorized: 401,
+    PaymentRequired: 402,
+    Forbidden: 403,
+    NotFound: 404,
+    MethodNotAllowed: 405,
+    NotAcceptable: 406,
+    ProxyAuthenticationRequired: 407,
+    RequestTimeout: 408,
+    Conflict: 409,
+    Gone: 410,
+    LengthRequired: 411,
+    PreconditionFailed: 412,
+    PayloadTooLarge: 413,
+    UriTooLong: 414,
+    UnsupportedMediaType: 415,
+    RangeNotSatisfiable: 416,
+    ExpectationFailed: 417,
+    ImATeapot: 418,
+    MisdirectedRequest: 421,
+    UnprocessableEntity: 422,
+    Locked: 423,
+    FailedDependency: 424,
+    TooEarly: 425,
+    UpgradeRequired: 426,
+    PreconditionRequired: 428,
+    TooManyRequests: 429,
+    RequestHeaderFieldsTooLarge: 431,
+    UnavailableForLegalReasons: 451,
+    InternalServerError: 500,
+    NotImplemented: 501,
+    BadGateway: 502,
+    ServiceUnavailable: 503,
+    GatewayTimeout: 504,
+    HttpVersionNotSupported: 505,
+    VariantAlsoNegotiates: 506,
+    InsufficientStorage: 507,
+    LoopDetected: 508,
+    NotExtended: 510,
+    NetworkAuthenticationRequired: 511
+};
+Object.entries(HttpStatusCode).forEach(([key, value])=>{
+    HttpStatusCode[value] = key;
+});
+export default HttpStatusCode;

package/lib/helpers/README.md

@@ -0,0 +1,7 @@
+# axios // helpers
+
+The modules found in `helpers/` should be generic modules that are _not_ specific to the domain logic of axios. These modules could theoretically be published to npm on their own and consumed by other modules or apps. Some examples of generic modules are things like:
+
+- Browser polyfills
+- Managing cookies
+- Parsing HTTP headers

package/lib/helpers/ZlibHeaderTransformStream.js

@@ -0,0 +1,22 @@
+"use strict";
+import stream from "stream";
+let ZlibHeaderTransformStream = class ZlibHeaderTransformStream extends stream.Transform {
+    __transform(chunk, encoding, callback) {
+        this.push(chunk);
+        callback();
+    }
+    _transform(chunk, encoding, callback) {
+        if (chunk.length !== 0) {
+            this._transform = this.__transform;
+            // Add Default Compression headers if no zlib headers are present
+            if (chunk[0] !== 120) {
+                const header = Buffer.alloc(2);
+                header[0] = 120; // Hex: 78
+                header[1] = 156; // Hex: 9C 
+                this.push(header, encoding);
+            }
+        }
+        this.__transform(chunk, encoding, callback);
+    }
+};
+export default ZlibHeaderTransformStream;

package/lib/helpers/bind.js

@@ -0,0 +1,6 @@
+'use strict';
+export default function bind(fn, thisArg) {
+    return function wrap() {
+        return fn.apply(thisArg, arguments);
+    };
+}

package/lib/helpers/buildURL.js

@@ -0,0 +1,42 @@
+'use strict';
+import utils from '../utils.js';
+import AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';
+/**
+ * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
+ * URI encoded counterparts
+ *
+ * @param {string} val The value to be encoded.
+ *
+ * @returns {string} The encoded value.
+ */ function encode(val) {
+    return encodeURIComponent(val).replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
+}
+/**
+ * Build a URL by appending params to the end
+ *
+ * @param {string} url The base of the url (e.g., http://www.google.com)
+ * @param {object} [params] The params to be appended
+ * @param {?object} options
+ *
+ * @returns {string} The formatted url
+ */ export default function buildURL(url, params, options) {
+    /*eslint no-param-reassign:0*/ if (!params) {
+        return url;
+    }
+    const _encode = options && options.encode || encode;
+    const serializeFn = options && options.serialize;
+    let serializedParams;
+    if (serializeFn) {
+        serializedParams = serializeFn(params, options);
+    } else {
+        serializedParams = utils.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
+    }
+    if (serializedParams) {
+        const hashmarkIndex = url.indexOf("#");
+        if (hashmarkIndex !== -1) {
+            url = url.slice(0, hashmarkIndex);
+        }
+        url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+    }
+    return url;
+}

package/lib/helpers/callbackify.js

@@ -0,0 +1,14 @@
+import utils from "../utils.js";
+const callbackify = (fn, reducer)=>{
+    return utils.isAsyncFn(fn) ? function(...args) {
+        const cb = args.pop();
+        fn.apply(this, args).then((value)=>{
+            try {
+                reducer ? cb(null, ...reducer(value)) : cb(null, value);
+            } catch (err) {
+                cb(err);
+            }
+        }, cb);
+    } : fn;
+};
+export default callbackify;

package/lib/helpers/combineURLs.js

@@ -0,0 +1,11 @@
+'use strict';
+/**
+ * Creates a new URL by combining the specified URLs
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} relativeURL The relative URL
+ *
+ * @returns {string} The combined URL
+ */ export default function combineURLs(baseURL, relativeURL) {
+    return relativeURL ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL;
+}

package/lib/helpers/composeSignals.js

@@ -0,0 +1,37 @@
+import CanceledError from "../cancel/CanceledError.js";
+import AxiosError from "../core/AxiosError.js";
+import utils from '../utils.js';
+const composeSignals = (signals, timeout)=>{
+    const { length } = signals = signals ? signals.filter(Boolean) : [];
+    if (timeout || length) {
+        let controller = new AbortController();
+        let aborted;
+        const onabort = function(reason) {
+            if (!aborted) {
+                aborted = true;
+                unsubscribe();
+                const err = reason instanceof Error ? reason : this.reason;
+                controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
+            }
+        };
+        let timer = timeout && setTimeout(()=>{
+            timer = null;
+            onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT));
+        }, timeout);
+        const unsubscribe = ()=>{
+            if (signals) {
+                timer && clearTimeout(timer);
+                timer = null;
+                signals.forEach((signal)=>{
+                    signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);
+                });
+                signals = null;
+            }
+        };
+        signals.forEach((signal)=>signal.addEventListener('abort', onabort));
+        const { signal } = controller;
+        signal.unsubscribe = ()=>utils.asap(unsubscribe);
+        return signal;
+    }
+};
+export default composeSignals;

package/lib/helpers/cookies.js

@@ -0,0 +1,29 @@
+import utils from './../utils.js';
+import platform from '../platform/index.js';
+export default platform.hasStandardBrowserEnv ? // Standard browser envs support document.cookie
+{
+    write (name, value, expires, path, domain, secure) {
+        const cookie = [
+            name + '=' + encodeURIComponent(value)
+        ];
+        utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
+        utils.isString(path) && cookie.push('path=' + path);
+        utils.isString(domain) && cookie.push('domain=' + domain);
+        secure === true && cookie.push('secure');
+        document.cookie = cookie.join('; ');
+    },
+    read (name) {
+        const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+        return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove (name) {
+        this.write(name, '', Date.now() - 86400000);
+    }
+} : // Non-standard browser env (web workers, react-native) lack needed support.
+{
+    write () {},
+    read () {
+        return null;
+    },
+    remove () {}
+};

package/lib/helpers/deprecatedMethod.js

@@ -0,0 +1,18 @@
+'use strict';
+/*eslint no-console:0*/ /**
+ * Supply a warning to the developer that a method they are using
+ * has been deprecated.
+ *
+ * @param {string} method The name of the deprecated method
+ * @param {string} [instead] The alternate method to use if applicable
+ * @param {string} [docs] The documentation URL to get further details
+ *
+ * @returns {void}
+ */ export default function deprecatedMethod(method, instead, docs) {
+    try {
+        console.warn('DEPRECATED method `' + method + '`.' + (instead ? ' Use `' + instead + '` instead.' : '') + ' This method will be removed in a future release.');
+        if (docs) {
+            console.warn('For more information about usage see ' + docs);
+        }
+    } catch (e) {}
+}

package/lib/helpers/formDataToJSON.js

@@ -0,0 +1,78 @@
+'use strict';
+import utils from '../utils.js';
+/**
+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
+ *
+ * @param {string} name - The name of the property to get.
+ *
+ * @returns An array of strings.
+ */ function parsePropPath(name) {
+    // foo[x][y][z]
+    // foo.x.y.z
+    // foo-x-y-z
+    // foo x y z
+    return utils.matchAll(/\w+|\[(\w*)]/g, name).map((match)=>{
+        return match[0] === '[]' ? '' : match[1] || match[0];
+    });
+}
+/**
+ * Convert an array to an object.
+ *
+ * @param {Array<any>} arr - The array to convert to an object.
+ *
+ * @returns An object with the same keys and values as the array.
+ */ function arrayToObject(arr) {
+    const obj = {};
+    const keys = Object.keys(arr);
+    let i;
+    const len = keys.length;
+    let key;
+    for(i = 0; i < len; i++){
+        key = keys[i];
+        obj[key] = arr[key];
+    }
+    return obj;
+}
+/**
+ * It takes a FormData object and returns a JavaScript object
+ *
+ * @param {string} formData The FormData object to convert to JSON.
+ *
+ * @returns {Object<string, any> | null} The converted object.
+ */ function formDataToJSON(formData) {
+    function buildPath(path, value, target, index) {
+        let name = path[index++];
+        if (name === '__proto__') return true;
+        const isNumericKey = Number.isFinite(+name);
+        const isLast = index >= path.length;
+        name = !name && utils.isArray(target) ? target.length : name;
+        if (isLast) {
+            if (utils.hasOwnProp(target, name)) {
+                target[name] = [
+                    target[name],
+                    value
+                ];
+            } else {
+                target[name] = value;
+            }
+            return !isNumericKey;
+        }
+        if (!target[name] || !utils.isObject(target[name])) {
+            target[name] = [];
+        }
+        const result = buildPath(path, value, target[name], index);
+        if (result && utils.isArray(target[name])) {
+            target[name] = arrayToObject(target[name]);
+        }
+        return !isNumericKey;
+    }
+    if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+        const obj = {};
+        utils.forEachEntry(formData, (name, value)=>{
+            buildPath(parsePropPath(name), value, obj, 0);
+        });
+        return obj;
+    }
+    return null;
+}
+export default formDataToJSON;

package/lib/helpers/formDataToStream.js

@@ -0,0 +1,77 @@
+import { TextEncoder } from 'util';
+import { Readable } from 'stream';
+import utils from "../utils.js";
+import readBlob from "./readBlob.js";
+const BOUNDARY_ALPHABET = utils.ALPHABET.ALPHA_DIGIT + '-_';
+const textEncoder = new TextEncoder();
+const CRLF = '\r\n';
+const CRLF_BYTES = textEncoder.encode(CRLF);
+const CRLF_BYTES_COUNT = 2;
+let FormDataPart = class FormDataPart {
+    constructor(name, value){
+        const { escapeName } = this.constructor;
+        const isStringValue = utils.isString(value);
+        let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${!isStringValue && value.name ? `; filename="${escapeName(value.name)}"` : ''}${CRLF}`;
+        if (isStringValue) {
+            value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
+        } else {
+            headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`;
+        }
+        this.headers = textEncoder.encode(headers + CRLF);
+        this.contentLength = isStringValue ? value.byteLength : value.size;
+        this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
+        this.name = name;
+        this.value = value;
+    }
+    async *encode() {
+        yield this.headers;
+        const { value } = this;
+        if (utils.isTypedArray(value)) {
+            yield value;
+        } else {
+            yield* readBlob(value);
+        }
+        yield CRLF_BYTES;
+    }
+    static escapeName(name) {
+        return String(name).replace(/[\r\n"]/g, (match)=>({
+                '\r': '%0D',
+                '\n': '%0A',
+                '"': '%22'
+            })[match]);
+    }
+};
+const formDataToStream = (form, headersHandler, options)=>{
+    const { tag = 'form-data-boundary', size = 25, boundary = tag + '-' + utils.generateString(size, BOUNDARY_ALPHABET) } = options || {};
+    if (!utils.isFormData(form)) {
+        throw TypeError('FormData instance required');
+    }
+    if (boundary.length < 1 || boundary.length > 70) {
+        throw Error('boundary must be 10-70 characters long');
+    }
+    const boundaryBytes = textEncoder.encode('--' + boundary + CRLF);
+    const footerBytes = textEncoder.encode('--' + boundary + '--' + CRLF + CRLF);
+    let contentLength = footerBytes.byteLength;
+    const parts = Array.from(form.entries()).map(([name, value])=>{
+        const part = new FormDataPart(name, value);
+        contentLength += part.size;
+        return part;
+    });
+    contentLength += boundaryBytes.byteLength * parts.length;
+    contentLength = utils.toFiniteNumber(contentLength);
+    const computedHeaders = {
+        'Content-Type': `multipart/form-data; boundary=${boundary}`
+    };
+    if (Number.isFinite(contentLength)) {
+        computedHeaders['Content-Length'] = contentLength;
+    }
+    headersHandler && headersHandler(computedHeaders);
+    return Readable.from(async function*() {
+        for (const part of parts){
+            yield boundaryBytes;
+            yield* part.encode();
+        }
+        yield footerBytes;
+    }());
+};
+export default formDataToStream;

package/lib/helpers/fromDataURI.js

@@ -0,0 +1,44 @@
+'use strict';
+import AxiosError from '../core/AxiosError.js';
+import parseProtocol from './parseProtocol.js';
+import platform from '../platform/index.js';
+const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
+/**
+ * Parse data uri to a Buffer or Blob
+ *
+ * @param {String} uri
+ * @param {?Boolean} asBlob
+ * @param {?Object} options
+ * @param {?Function} options.Blob
+ *
+ * @returns {Buffer|Blob}
+ */ export default function fromDataURI(uri, asBlob, options) {
+    const _Blob = options && options.Blob || platform.classes.Blob;
+    const protocol = parseProtocol(uri);
+    if (asBlob === undefined && _Blob) {
+        asBlob = true;
+    }
+    if (protocol === 'data') {
+        uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
+        const match = DATA_URL_PATTERN.exec(uri);
+        if (!match) {
+            throw new AxiosError('Invalid URL', AxiosError.ERR_INVALID_URL);
+        }
+        const mime = match[1];
+        const isBase64 = match[2];
+        const body = match[3];
+        const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');
+        if (asBlob) {
+            if (!_Blob) {
+                throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT);
+            }
+            return new _Blob([
+                buffer
+            ], {
+                type: mime
+            });
+        }
+        return buffer;
+    }
+    throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);
+}

package/lib/helpers/isAbsoluteURL.js

@@ -0,0 +1,13 @@
+'use strict';
+/**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ *
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */ export default function isAbsoluteURL(url) {
+    // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+    // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+    // by any combination of letters, digits, plus, period, or hyphen.
+    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}

package/lib/helpers/isAxiosError.js

@@ -0,0 +1,11 @@
+'use strict';
+import utils from './../utils.js';
+/**
+ * Determines whether the payload is an error thrown by Axios
+ *
+ * @param {*} payload The value to test
+ *
+ * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
+ */ export default function isAxiosError(payload) {
+    return utils.isObject(payload) && payload.isAxiosError === true;
+}

package/lib/helpers/isURLSameOrigin.js

@@ -0,0 +1,50 @@
+'use strict';
+import utils from './../utils.js';
+import platform from '../platform/index.js';
+export default platform.hasStandardBrowserEnv ? // Standard browser envs have full support of the APIs needed to test
+// whether the request URL is of the same origin as current location.
+function standardBrowserEnv() {
+    const msie = platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent);
+    const urlParsingNode = document.createElement('a');
+    let originURL;
+    /**
+    * Parse a URL to discover its components
+    *
+    * @param {String} url The URL to be parsed
+    * @returns {Object}
+    */ function resolveURL(url) {
+        let href = url;
+        if (msie) {
+            // IE needs attribute set twice to normalize properties
+            urlParsingNode.setAttribute('href', href);
+            href = urlParsingNode.href;
+        }
+        urlParsingNode.setAttribute('href', href);
+        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+        return {
+            href: urlParsingNode.href,
+            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+            host: urlParsingNode.host,
+            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+            hostname: urlParsingNode.hostname,
+            port: urlParsingNode.port,
+            pathname: urlParsingNode.pathname.charAt(0) === '/' ? urlParsingNode.pathname : '/' + urlParsingNode.pathname
+        };
+    }
+    originURL = resolveURL(window.location.href);
+    /**
+    * Determine if a URL shares the same origin as the current location
+    *
+    * @param {String} requestURL The URL to test
+    * @returns {boolean} True if URL shares the same origin, otherwise false
+    */ return function isURLSameOrigin(requestURL) {
+        const parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+        return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+    };
+}() : // Non standard browser envs (web workers, react-native) lack needed support.
+function nonStandardBrowserEnv() {
+    return function isURLSameOrigin() {
+        return true;
+    };
+}();

package/lib/helpers/null.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line strict
+export default null;

package/lib/helpers/parseHeaders.js

@@ -0,0 +1,61 @@
+import utils from '../utils.js';
+// RawAxiosHeaders whose duplicates are ignored by node
+// c.f. https://nodejs.org/api/http.html#http_message_headers
+const ignoreDuplicateOf = utils.toObjectSet([
+    'age',
+    'authorization',
+    'content-length',
+    'content-type',
+    'etag',
+    'expires',
+    'from',
+    'host',
+    'if-modified-since',
+    'if-unmodified-since',
+    'last-modified',
+    'location',
+    'max-forwards',
+    'proxy-authorization',
+    'referer',
+    'retry-after',
+    'user-agent'
+]);
+/**
+ * Parse headers into an object
+ *
+ * ```
+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
+ * Content-Type: application/json
+ * Connection: keep-alive
+ * Transfer-Encoding: chunked
+ * ```
+ *
+ * @param {String} rawHeaders Headers needing to be parsed
+ *
+ * @returns {Object} Headers parsed into an object
+ */ export default ((rawHeaders)=>{
+    const parsed = {};
+    let key;
+    let val;
+    let i;
+    rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
+        i = line.indexOf(':');
+        key = line.substring(0, i).trim().toLowerCase();
+        val = line.substring(i + 1).trim();
+        if (!key || parsed[key] && ignoreDuplicateOf[key]) {
+            return;
+        }
+        if (key === 'set-cookie') {
+            if (parsed[key]) {
+                parsed[key].push(val);
+            } else {
+                parsed[key] = [
+                    val
+                ];
+            }
+        } else {
+            parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+        }
+    });
+    return parsed;
+});

package/lib/helpers/parseProtocol.js

@@ -0,0 +1,5 @@
+'use strict';
+export default function parseProtocol(url) {
+    const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+    return match && match[1] || '';
+}

package/lib/helpers/progressEventReducer.js

@@ -0,0 +1,54 @@
+import speedometer from './speedometer.js';
+import throttle from './throttle.js';
+import utils from '../utils.js';
+/**
+ *
+ * @param {*} listener
+ * @param {*} isDownloadStream
+ * @param {*} freq
+ * @returns
+ */ export const progressEventReducer = (listener, isDownloadStream, freq = 3)=>{
+    let bytesNotified = 0;
+    const _speedometer = speedometer(50, 250);
+    return throttle((e)=>{
+        const loaded = e.loaded;
+        const total = e.lengthComputable ? e.total : undefined;
+        const progressBytes = loaded - bytesNotified;
+        const rate = _speedometer(progressBytes);
+        const inRange = loaded <= total;
+        bytesNotified = loaded;
+        const data = {
+            loaded,
+            total,
+            progress: total ? loaded / total : undefined,
+            bytes: progressBytes,
+            rate: rate ? rate : undefined,
+            estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
+            event: e,
+            lengthComputable: total != null,
+            [isDownloadStream ? 'download' : 'upload']: true
+        };
+        listener(data);
+    }, freq);
+};
+/**
+ *
+ * @param {*} total
+ * @param {*} throttled
+ * @returns
+ */ export const progressEventDecorator = (total, throttled)=>{
+    const lengthComputable = total != null;
+    return [
+        (loaded)=>throttled[0]({
+                lengthComputable,
+                total,
+                loaded
+            }),
+        throttled[1]
+    ];
+};
+/**
+ *
+ * @param {*} fn
+ * @returns
+ */ export const asyncDecorator = (fn)=>(...args)=>utils.asap(()=>fn(...args));