@wiajs/req 1.7.7

package/lib/adapters/xhr.js

@@ -0,0 +1,200 @@
+import utils from '../utils.js';
+import settle from '../core/settle.js';
+import cookies from '../helpers/cookies.js';
+import buildURL from '../helpers/buildURL.js';
+import buildFullPath from '../core/buildFullPath.js';
+import isURLSameOrigin from '../helpers/isURLSameOrigin.js';
+import transitionalDefaults from '../defaults/transitional.js';
+import AxiosError from '../core/AxiosError.js';
+import CanceledError from '../cancel/CanceledError.js';
+import parseProtocol from '../helpers/parseProtocol.js';
+import platform from '../platform/index.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
+import speedometer from '../helpers/speedometer.js';
+function progressEventReducer(listener, isDownloadStream) {
+    let bytesNotified = 0;
+    const _speedometer = speedometer(50, 250);
+    return (e)=>{
+        const { loaded } = e;
+        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
+        };
+        data[isDownloadStream ? 'download' : 'upload'] = true;
+        listener(data);
+    };
+}
+const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
+let XhrAdapter = class XhrAdapter {
+    constructor(config){
+        this.init(config);
+    }
+    init(config) {}
+    request() {}
+    stream() {}
+};
+export default isXHRAdapterSupported && XhrAdapter;
+function req(config) {
+    return new Promise((resolve, reject)=>{
+        const { data: requestData, responseType } = config;
+        const requestHeaders = AxiosHeaders.from(config.headers).normalize();
+        let onCanceled;
+        function done() {
+            if (config.cancelToken) config.cancelToken.unsubscribe(onCanceled);
+            if (config.signal) config.signal.removeEventListener('abort', onCanceled);
+        }
+        if (utils.isFormData(requestData) && platform.isStandardBrowserEnv) requestHeaders.setContentType(false); // Let the browser set it
+        let request = new XMLHttpRequest();
+        // HTTP basic authentication
+        if (config.auth) {
+            const username = config.auth.username || '';
+            const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
+            requestHeaders.set('Authorization', 'Basic ' + btoa(username + ':' + password));
+        }
+        const fullPath = buildFullPath(config.baseURL, config.url);
+        request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+        // Set the request timeout in MS
+        request.timeout = config.timeout;
+        function onloadend() {
+            if (!request) {
+                return;
+            }
+            // Prepare the response
+            const responseHeaders = AxiosHeaders.from('getAllResponseHeaders' in request && request.getAllResponseHeaders());
+            const responseData = !responseType || responseType === 'text' || responseType === 'json' ? request.responseText : request.response;
+            const response = {
+                data: responseData,
+                status: request.status,
+                statusText: request.statusText,
+                headers: responseHeaders,
+                config,
+                request
+            };
+            settle(function _resolve(value) {
+                resolve(value);
+                done();
+            }, function _reject(err) {
+                reject(err);
+                done();
+            }, response);
+            // Clean up request
+            request = null;
+        }
+        if ('onloadend' in request) {
+            // Use onloadend if available
+            request.onloadend = onloadend;
+        } else {
+            // Listen for ready state to emulate onloadend
+            request.onreadystatechange = function handleLoad() {
+                if (!request || request.readyState !== 4) {
+                    return;
+                }
+                // The request errored out and we didn't get a response, this will be
+                // handled by onerror instead
+                // With one exception: request that using file: protocol, most browsers
+                // will return status as 0 even though it's a successful request
+                if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
+                    return;
+                }
+                // readystate handler is calling before onerror or ontimeout handlers,
+                // so we should call onloadend on the next 'tick'
+                setTimeout(onloadend);
+            };
+        }
+        // Handle browser request cancellation (as opposed to a manual cancellation)
+        request.onabort = function handleAbort() {
+            if (!request) {
+                return;
+            }
+            reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));
+            // Clean up request
+            request = null;
+        };
+        // Handle low level network errors
+        request.onerror = function handleError() {
+            // Real errors are hidden from us by the browser
+            // onerror should only fire if it's a network error
+            reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
+            // Clean up request
+            request = null;
+        };
+        // Handle timeout
+        request.ontimeout = function handleTimeout() {
+            let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
+            const transitional = config.transitional || transitionalDefaults;
+            if (config.timeoutErrorMessage) {
+                timeoutErrorMessage = config.timeoutErrorMessage;
+            }
+            reject(new AxiosError(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED, config, request));
+            // Clean up request
+            request = null;
+        };
+        // Add xsrf header
+        // This is only done if running in a standard browser environment.
+        // Specifically not if we're in a web worker, or react-native.
+        if (platform.isStandardBrowserEnv) {
+            // Add xsrf header
+            const xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName && cookies.read(config.xsrfCookieName);
+            if (xsrfValue) {
+                requestHeaders.set(config.xsrfHeaderName, xsrfValue);
+            }
+        }
+        // Remove Content-Type if data is undefined
+        requestData === undefined && requestHeaders.setContentType(null);
+        // Add headers to the request
+        if ('setRequestHeader' in request) {
+            utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+                request.setRequestHeader(key, val);
+            });
+        }
+        // Add withCredentials to request if needed
+        if (!utils.isUndefined(config.withCredentials)) {
+            request.withCredentials = !!config.withCredentials;
+        }
+        // Add responseType to request if needed
+        if (responseType && responseType !== 'json') {
+            request.responseType = config.responseType;
+        }
+        // Handle progress if needed
+        if (typeof config.onDownloadProgress === 'function') {
+            request.addEventListener('progress', progressEventReducer(config.onDownloadProgress, true));
+        }
+        // Not all browsers support upload events
+        if (typeof config.onUploadProgress === 'function' && request.upload) {
+            request.upload.addEventListener('progress', progressEventReducer(config.onUploadProgress));
+        }
+        if (config.cancelToken || config.signal) {
+            // Handle cancellation
+            // eslint-disable-next-line func-names
+            onCanceled = (cancel)=>{
+                if (!request) {
+                    return;
+                }
+                reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
+                request.abort();
+                request = null;
+            };
+            config.cancelToken && config.cancelToken.subscribe(onCanceled);
+            if (config.signal) {
+                config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
+            }
+        }
+        const protocol = parseProtocol(fullPath);
+        if (protocol && platform.protocols.indexOf(protocol) === -1) {
+            reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
+            return;
+        }
+        // Send the request
+        request.send(requestData || null);
+    });
+}

package/lib/axios.js

@@ -0,0 +1,89 @@
+'use strict';
+
+import utils from './utils.js';
+import bind from './helpers/bind.js';
+import Axios from './core/Axios.js';
+import mergeConfig from './core/mergeConfig.js';
+import defaults from './defaults/index.js';
+import formDataToJSON from './helpers/formDataToJSON.js';
+import CanceledError from './cancel/CanceledError.js';
+import CancelToken from './cancel/CancelToken.js';
+import isCancel from './cancel/isCancel.js';
+import {VERSION} from './env/data.js';
+import toFormData from './helpers/toFormData.js';
+import AxiosError from './core/AxiosError.js';
+import spread from './helpers/spread.js';
+import isAxiosError from './helpers/isAxiosError.js';
+import AxiosHeaders from "./core/AxiosHeaders.js";
+import adapters from './adapters/adapters.js';
+import HttpStatusCode from './helpers/HttpStatusCode.js';
+
+/**
+ * Create an instance of Axios
+ *
+ * @param {Object} defaultConfig The default config for the instance
+ *
+ * @returns {Axios} A new instance of Axios
+ */
+function createInstance(defaultConfig) {
+  const context = new Axios(defaultConfig);
+  const instance = bind(Axios.prototype.request, context);
+
+  // Copy axios.prototype to instance
+  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});
+
+  // Copy context to instance
+  utils.extend(instance, context, null, {allOwnKeys: true});
+
+  // Factory for creating new instances
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
+  };
+
+  return instance;
+}
+
+// Create the default instance to be exported
+const axios = createInstance(defaults);
+
+// Expose Axios class to allow class inheritance
+axios.Axios = Axios;
+
+// Expose Cancel & CancelToken
+axios.CanceledError = CanceledError;
+axios.CancelToken = CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
+
+// Expose AxiosError class
+axios.AxiosError = AxiosError;
+
+// alias for CanceledError for backward compatibility
+axios.Cancel = axios.CanceledError;
+
+// Expose all/spread
+axios.all = function all(promises) {
+  return Promise.all(promises);
+};
+
+axios.spread = spread;
+
+// Expose isAxiosError
+axios.isAxiosError = isAxiosError;
+
+// Expose mergeConfig
+axios.mergeConfig = mergeConfig;
+
+axios.AxiosHeaders = AxiosHeaders;
+
+axios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
+
+axios.getAdapter = adapters.getAdapter;
+
+axios.HttpStatusCode = HttpStatusCode;
+
+axios.default = axios;
+
+// this module should only have a default export
+export default axios

package/lib/cancel/CancelToken.js

@@ -0,0 +1,106 @@
+'use strict';
+import CanceledError from './CanceledError.js';
+/**
+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
+ *
+ * @param {Function} executor The executor function.
+ *
+ * @returns {CancelToken}
+ */ let CancelToken = class CancelToken {
+    constructor(executor){
+        if (typeof executor !== 'function') {
+            throw new TypeError('executor must be a function.');
+        }
+        let resolvePromise;
+        this.promise = new Promise(function promiseExecutor(resolve) {
+            resolvePromise = resolve;
+        });
+        const token = this;
+        // eslint-disable-next-line func-names
+        this.promise.then((cancel)=>{
+            if (!token._listeners) return;
+            let i = token._listeners.length;
+            while(i-- > 0){
+                token._listeners[i](cancel);
+            }
+            token._listeners = null;
+        });
+        // eslint-disable-next-line func-names
+        this.promise.then = (onfulfilled)=>{
+            let _resolve;
+            // eslint-disable-next-line func-names
+            const promise = new Promise((resolve)=>{
+                token.subscribe(resolve);
+                _resolve = resolve;
+            }).then(onfulfilled);
+            promise.cancel = function reject() {
+                token.unsubscribe(_resolve);
+            };
+            return promise;
+        };
+        executor(function cancel(message, config, request) {
+            if (token.reason) {
+                // Cancellation has already been requested
+                return;
+            }
+            token.reason = new CanceledError(message, config, request);
+            resolvePromise(token.reason);
+        });
+    }
+    /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */ throwIfRequested() {
+        if (this.reason) {
+            throw this.reason;
+        }
+    }
+    /**
+   * Subscribe to the cancel signal
+   */ subscribe(listener) {
+        if (this.reason) {
+            listener(this.reason);
+            return;
+        }
+        if (this._listeners) {
+            this._listeners.push(listener);
+        } else {
+            this._listeners = [
+                listener
+            ];
+        }
+    }
+    /**
+   * Unsubscribe from the cancel signal
+   */ unsubscribe(listener) {
+        if (!this._listeners) {
+            return;
+        }
+        const index = this._listeners.indexOf(listener);
+        if (index !== -1) {
+            this._listeners.splice(index, 1);
+        }
+    }
+    toAbortSignal() {
+        const controller = new AbortController();
+        const abort = (err)=>{
+            controller.abort(err);
+        };
+        this.subscribe(abort);
+        controller.signal.unsubscribe = ()=>this.unsubscribe(abort);
+        return controller.signal;
+    }
+    /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */ static source() {
+        let cancel;
+        const token = new CancelToken(function executor(c) {
+            cancel = c;
+        });
+        return {
+            token,
+            cancel
+        };
+    }
+};
+export default CancelToken;

package/lib/cancel/CanceledError.js

@@ -0,0 +1,20 @@
+'use strict';
+import AxiosError from '../core/AxiosError.js';
+import utils from '../utils.js';
+/**
+ * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @param {string=} message The message.
+ * @param {Object=} config The config.
+ * @param {Object=} request The request.
+ *
+ * @returns {CanceledError} The created error.
+ */ function CanceledError(message, config, request) {
+    // eslint-disable-next-line no-eq-null,eqeqeq
+    AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
+    this.name = 'CanceledError';
+}
+utils.inherits(CanceledError, AxiosError, {
+    __CANCEL__: true
+});
+export default CanceledError;

package/lib/cancel/isCancel.js

@@ -0,0 +1,4 @@
+'use strict';
+export default function isCancel(value) {
+    return !!(value && value.__CANCEL__);
+}