@wiajs/req 1.7.7

package/lib/core/Axios.js

@@ -0,0 +1,359 @@
+import utils from '../utils.js';
+import buildURL from '../helpers/buildURL.js';
+import InterceptorManager from './InterceptorManager.js';
+import dispatchRequest from './dispatchRequest.js';
+import mergeConfig from './mergeConfig.js';
+import buildFullPath from './buildFullPath.js';
+import validator from '../helpers/validator.js';
+import AxiosHeaders from './AxiosHeaders.js';
+const { validators } = validator;
+/**
+ * Create a new instance of Axios
+ *
+ * @param {Object} instanceConfig The default config for the instance
+ *
+ * @return {Axios} A new instance of Axios
+ */ let Axios = class Axios {
+    constructor(instanceConfig){
+        this.defaults = instanceConfig;
+        this.config = this.defaults // !+++
+        ;
+        this.interceptors = {
+            request: new InterceptorManager(),
+            response: new InterceptorManager()
+        };
+        this.init() // !+++
+        ;
+    }
+    /**
+   * !+++
+   * config 属性直接挂在到实例上，方便读取、设置、修改
+   * 需注意，不要与其属性、方法冲突！！！
+    request(config)
+    get(url[, config])
+    delete(url[, config])
+    head(url[, config])
+    options(url[, config])
+    post(url[, data[, config]])
+    put(url[, data[, config]])
+    patch(url[, data[, config]])
+    getUri([config])
+   */ init() {
+        const m = this;
+        [
+            'url',
+            'method',
+            'baseURL',
+            'transformRequest',
+            'transformResponse',
+            'headers',
+            'params',
+            'paramsSerializer',
+            'body',
+            'data',
+            'timeout',
+            'withCredentials',
+            'adapter',
+            'auth',
+            'responseType',
+            'responseEncoding',
+            'xsrfCookieName',
+            'xsrfHeaderName',
+            'onUploadProgress',
+            'onDownloadProgress',
+            'maxContentLength',
+            'maxBodyLength',
+            'validateStatus',
+            'maxRedirects',
+            'beforeRedirect',
+            'socketPath',
+            'httpAgent',
+            'httpsAgent',
+            'agent',
+            'cancelToken',
+            'signal',
+            'decompress',
+            'insecureHTTPParser',
+            'transitional',
+            'env',
+            'formSerializer',
+            'maxRate'
+        ].forEach((p)=>Object.defineProperty(m, p, {
+                enumerable: true,
+                get () {
+                    return m.config[p];
+                },
+                set (value) {
+                    m.config[p] = value;
+                }
+            }));
+    }
+    /**
+   * Dispatch a request
+   * 启动执行请求，返回 Promise 实例
+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+   * @param {?Object} config
+   * @returns {Promise} The Promise to be fulfilled
+   */ async request(configOrUrl, config) {
+        try {
+            return await this._request(configOrUrl, config);
+        } catch (err) {
+            if (err instanceof Error) {
+                let dummy = {};
+                Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
+                // slice off the Error: ... line
+                const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
+                try {
+                    if (!err.stack) {
+                        err.stack = stack;
+                    // match without the 2 top stack lines
+                    } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) {
+                        err.stack += '\n' + stack;
+                    }
+                } catch (e) {
+                // ignore the case where "stack" is an un-writable property
+                }
+            }
+            throw err // 抛出异常
+            ;
+        }
+    }
+    /**
+   * 执行请求
+   * @param {*} configOrUrl
+   * @param {*} config
+   * @param {boolean} [stream = false] - 是否返回 stream
+   * @returns
+   */ _request(configOrUrl, config, stream = false) {
+        let R = null;
+        const m = this;
+        /* eslint no-param-reassign:0 */ // Allow for axios('example/url'[, config]) a la fetch API
+        if (typeof configOrUrl === 'string') {
+            config = config || {};
+            config.url = configOrUrl;
+        } else {
+            config = configOrUrl || {};
+        }
+        // ! body as data alias, body ==> data，内部保持data不变
+        if (!config.data && config.body) {
+            config.data = config.body;
+        // config.body = undefined;
+        }
+        config = mergeConfig(this.defaults, config);
+        const { transitional, paramsSerializer, headers } = config;
+        if (transitional !== undefined) {
+            validator.assertOptions(transitional, {
+                silentJSONParsing: validators.transitional(validators.boolean),
+                forcedJSONParsing: validators.transitional(validators.boolean),
+                clarifyTimeoutError: validators.transitional(validators.boolean)
+            }, false);
+        }
+        if (paramsSerializer) {
+            if (utils.isFunction(paramsSerializer)) {
+                config.paramsSerializer = {
+                    serialize: paramsSerializer
+                };
+            } else {
+                validator.assertOptions(paramsSerializer, {
+                    encode: validators.function,
+                    serialize: validators.function
+                }, true);
+            }
+        }
+        validator.assertOptions(config, {
+            baseUrl: validators.spelling('baseURL'),
+            withXsrfToken: validators.spelling('withXSRFToken')
+        }, true);
+        // Set config.method
+        config.method = (config.method || this.defaults.method || 'get').toLowerCase();
+        // Flatten headers，方法头覆盖通用头
+        const contextHeaders = headers && utils.merge(headers.common, headers[config.method]);
+        headers && utils.forEach([
+            'delete',
+            'get',
+            'head',
+            'post',
+            'put',
+            'patch',
+            'common'
+        ], (method)=>{
+            delete headers[method];
+        });
+        // 源值存在，则不覆盖，contextHeaders 优先于 headers
+        config.headers = AxiosHeaders.concat(contextHeaders, headers);
+        // filter out skipped interceptors
+        const requestInterceptorChain = [] // 请求拦截器，hook
+        ;
+        let synchronousRequestInterceptors = true;
+        this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+            if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
+                return;
+            }
+            synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+            requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+        });
+        const responseInterceptorChain = [] // 响应拦截器，hook
+        ;
+        this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+            responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+        });
+        let promise;
+        let i = 0;
+        let len;
+        debugger;
+        // 执行dispatchRequest
+        // !+++ stream
+        if (stream) {
+            config.stream = true;
+            R = dispatchRequest.call(this, config) // not promise
+            ;
+        } else if (!synchronousRequestInterceptors) {
+            // 异步拦截器
+            const chain = [
+                dispatchRequest.bind(this),
+                undefined
+            ] // dispatchRequest 放入运行链
+            ;
+            chain.unshift(...requestInterceptorChain) // !*** 插入头
+            ;
+            chain.push(...responseInterceptorChain) // !*** 加入尾
+            ;
+            len = chain.length;
+            promise = Promise.resolve(config) // promise 对象
+            ;
+            // 传入config配置，按顺序执行
+            while(i < len)promise = promise.then(chain[i++], chain[i++]);
+            R = promise;
+        } else {
+            // 同步拦截器
+            len = requestInterceptorChain.length;
+            let newConfig = config;
+            i = 0;
+            // 按加入顺序运行 request 拦截器
+            while(i < len){
+                const onFulfilled = requestInterceptorChain[i++];
+                const onRejected = requestInterceptorChain[i++];
+                try {
+                    newConfig = onFulfilled(newConfig) // 执行
+                    ;
+                } catch (error) {
+                    onRejected.call(this, error);
+                    break;
+                }
+            }
+            try {
+                promise = dispatchRequest.call(this, newConfig);
+                i = 0;
+                len = responseInterceptorChain.length;
+                // 按顺序执行响应 hook
+                while(i < len)promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+                R = promise;
+            } catch (error) {
+                R = Promise.reject(error);
+            }
+        }
+        return R;
+    }
+    /**
+   * !+++
+   * 类似 request 库，返回 stream
+   * stream 模式下，拦截器无效
+   * 如需拦截器，请使用 responseType: 'stream'，data 为 stream 传出
+   * 或者 将 stream 作为 data 传入
+   * @param {*} configOrUrl
+   * @param {*} config
+   * @returns
+   */ stream(configOrUrl, config) {
+        return this._request(configOrUrl, config, true);
+    }
+    /**
+   *
+   * @param {*} config
+   * @returns
+   */ getUri(config) {
+        config = mergeConfig(this.defaults, config);
+        const fullPath = buildFullPath(config.baseURL, config.url);
+        return buildURL(fullPath, config.params, config.paramsSerializer);
+    }
+};
+// Provide aliases for supported request methods
+utils.forEach([
+    'head',
+    'options'
+], function forEachMethodNoData(method) {
+    /* eslint func-names:0 */ Axios.prototype[method] = function(url, config) {
+        return this.request(mergeConfig(config || {}, {
+            method,
+            url,
+            data: (config || {}).data
+        }));
+    };
+});
+// delete、get, 与 axios不同，第二个参数为 params，而不是 data
+utils.forEach([
+    'delete',
+    'get'
+], function forEachMethodNoData(method) {
+    Axios.prototype[method] = function(url, params, config) {
+        return this.request(mergeConfig(config || {}, {
+            method,
+            url,
+            params
+        }));
+    };
+});
+utils.forEach([
+    'post',
+    'put',
+    'patch'
+], function forEachMethodWithData(method) {
+    function generateHTTPMethod(isForm) {
+        return function httpMethod(url, data, config) {
+            return this.request(mergeConfig(config || {}, {
+                method,
+                headers: isForm ? {
+                    'Content-Type': 'multipart/form-data'
+                } : {},
+                url,
+                data
+            }));
+        };
+    }
+    Axios.prototype[method] = generateHTTPMethod();
+    Axios.prototype[`${method}Form`] = generateHTTPMethod(true);
+});
+// stream get, 与 axios不同，第二个参数为 params，而不是 data
+utils.forEach([
+    'gets'
+], function forEachMethodNoData(method) {
+    Axios.prototype[method] = function(url, params, config) {
+        return this.stream(mergeConfig(config || {}, {
+            method,
+            url,
+            params,
+            data: (config || {}).data
+        }));
+    };
+});
+// stream post put patch
+utils.forEach([
+    'posts',
+    'puts',
+    'patchs'
+], function forEachMethodWithData(method) {
+    function generateStreamMethod(isForm) {
+        return function httpMethod(url, data, config) {
+            return this.stream(mergeConfig(config || {}, {
+                method,
+                headers: isForm ? {
+                    'Content-Type': 'multipart/form-data'
+                } : {},
+                url,
+                data
+            }));
+        };
+    }
+    Axios.prototype[method] = generateStreamMethod();
+    Axios.prototype[`${method}Forms`] = generateStreamMethod(true);
+});
+export default Axios;

package/lib/core/AxiosError.js

@@ -0,0 +1,89 @@
+'use strict';
+import utils from '../utils.js';
+/**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [config] The config.
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ *
+ * @returns {Error} The created error.
+ */ function AxiosError(message, code, config, request, response) {
+    Error.call(this);
+    if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+    } else {
+        this.stack = new Error().stack;
+    }
+    this.message = message;
+    this.name = 'AxiosError';
+    code && (this.code = code);
+    config && (this.config = config);
+    request && (this.request = request);
+    if (response) {
+        this.response = response;
+        this.status = response.status ? response.status : null;
+    }
+}
+utils.inherits(AxiosError, Error, {
+    toJSON: function toJSON() {
+        return {
+            // Standard
+            message: this.message,
+            name: this.name,
+            // Microsoft
+            description: this.description,
+            number: this.number,
+            // Mozilla
+            fileName: this.fileName,
+            lineNumber: this.lineNumber,
+            columnNumber: this.columnNumber,
+            stack: this.stack,
+            // Axios
+            config: utils.toJSONObject(this.config),
+            code: this.code,
+            status: this.status
+        };
+    }
+});
+const prototype = AxiosError.prototype;
+const descriptors = {};
+[
+    'ERR_BAD_OPTION_VALUE',
+    'ERR_BAD_OPTION',
+    'ECONNABORTED',
+    'ETIMEDOUT',
+    'ERR_NETWORK',
+    'ERR_FR_TOO_MANY_REDIRECTS',
+    'ERR_DEPRECATED',
+    'ERR_BAD_RESPONSE',
+    'ERR_BAD_REQUEST',
+    'ERR_CANCELED',
+    'ERR_NOT_SUPPORT',
+    'ERR_INVALID_URL'
+].forEach((code)=>{
+    descriptors[code] = {
+        value: code
+    };
+});
+Object.defineProperties(AxiosError, descriptors);
+Object.defineProperty(prototype, 'isAxiosError', {
+    value: true
+});
+// eslint-disable-next-line func-names
+AxiosError.from = (error, code, config, request, response, customProps)=>{
+    const axiosError = Object.create(prototype);
+    utils.toFlatObject(error, axiosError, function filter(obj) {
+        return obj !== Error.prototype;
+    }, (prop)=>{
+        return prop !== 'isAxiosError';
+    });
+    AxiosError.call(axiosError, error.message, code, config, request, response);
+    axiosError.cause = error;
+    axiosError.name = error.name;
+    customProps && Object.assign(axiosError, customProps);
+    return axiosError;
+};
+export default AxiosError;

package/lib/core/AxiosHeaders.js

@@ -0,0 +1,243 @@
+'use strict';
+var _computedKey, _computedKey1;
+import utils from '../utils.js';
+import parseHeaders from '../helpers/parseHeaders.js';
+const $internals = Symbol('internals');
+function normalizeHeader(header) {
+    return header && String(header).trim().toLowerCase();
+}
+function normalizeValue(value) {
+    if (value === false || value == null) {
+        return value;
+    }
+    return utils.isArray(value) ? value.map(normalizeValue) : String(value);
+}
+function parseTokens(str) {
+    const tokens = Object.create(null);
+    const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+    let match;
+    while(match = tokensRE.exec(str)){
+        tokens[match[1]] = match[2];
+    }
+    return tokens;
+}
+const isValidHeaderName = (str)=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
+    if (utils.isFunction(filter)) {
+        return filter.call(this, value, header);
+    }
+    if (isHeaderNameFilter) {
+        value = header;
+    }
+    if (!utils.isString(value)) return;
+    if (utils.isString(filter)) {
+        return value.indexOf(filter) !== -1;
+    }
+    if (utils.isRegExp(filter)) {
+        return filter.test(value);
+    }
+}
+function formatHeader(header) {
+    return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str)=>{
+        return char.toUpperCase() + str;
+    });
+}
+function buildAccessors(obj, header) {
+    const accessorName = utils.toCamelCase(' ' + header);
+    [
+        'get',
+        'set',
+        'has'
+    ].forEach((methodName)=>{
+        Object.defineProperty(obj, methodName + accessorName, {
+            value: function(arg1, arg2, arg3) {
+                return this[methodName].call(this, header, arg1, arg2, arg3);
+            },
+            configurable: true
+        });
+    });
+}
+_computedKey = Symbol.iterator, _computedKey1 = Symbol.toStringTag;
+let AxiosHeaders = class AxiosHeaders {
+    constructor(headers){
+        headers && this.set(headers);
+    }
+    /**
+   *
+   * @param {*} header
+   * @param {*} valueOrRewrite
+   * @param {*} rewrite true：无论源值是否存在均赋值，false：源值如存在不覆盖，
+   * undefined：源值不为 false 直接赋值，false 不赋值
+   * @returns
+   */ set(header, valueOrRewrite, rewrite) {
+        const self = this;
+        function setHeader(_value, _header, _rewrite) {
+            const lHeader = normalizeHeader(_header);
+            if (!lHeader) {
+                throw new Error('header name must be a non-empty string');
+            }
+            const key = utils.findKey(self, lHeader);
+            if (!key || self[key] === undefined || _rewrite === true || _rewrite === undefined && self[key] !== false) {
+                self[key || _header] = normalizeValue(_value);
+            }
+        }
+        const setHeaders = (headers, _rewrite)=>utils.forEach(headers, (_value, _header)=>setHeader(_value, _header, _rewrite));
+        if (utils.isPlainObject(header) || header instanceof this.constructor) {
+            setHeaders(header, valueOrRewrite);
+        } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+            setHeaders(parseHeaders(header), valueOrRewrite);
+        } else if (utils.isHeaders(header)) {
+            for (const [key, value] of header.entries()){
+                setHeader(value, key, rewrite);
+            }
+        } else {
+            header != null && setHeader(valueOrRewrite, header, rewrite);
+        }
+        return this;
+    }
+    get(header, parser) {
+        header = normalizeHeader(header);
+        if (header) {
+            const key = utils.findKey(this, header);
+            if (key) {
+                const value = this[key];
+                if (!parser) {
+                    return value;
+                }
+                if (parser === true) {
+                    return parseTokens(value);
+                }
+                if (utils.isFunction(parser)) {
+                    return parser.call(this, value, key);
+                }
+                if (utils.isRegExp(parser)) {
+                    return parser.exec(value);
+                }
+                throw new TypeError('parser must be boolean|regexp|function');
+            }
+        }
+    }
+    has(header, matcher) {
+        header = normalizeHeader(header);
+        if (header) {
+            const key = utils.findKey(this, header);
+            return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+        }
+        return false;
+    }
+    delete(header, matcher) {
+        const self = this;
+        let deleted = false;
+        function deleteHeader(_header) {
+            _header = normalizeHeader(_header);
+            if (_header) {
+                const key = utils.findKey(self, _header);
+                if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
+                    delete self[key];
+                    deleted = true;
+                }
+            }
+        }
+        if (utils.isArray(header)) {
+            header.forEach(deleteHeader);
+        } else {
+            deleteHeader(header);
+        }
+        return deleted;
+    }
+    clear(matcher) {
+        const keys = Object.keys(this);
+        let i = keys.length;
+        let deleted = false;
+        while(i--){
+            const key = keys[i];
+            if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+                delete this[key];
+                deleted = true;
+            }
+        }
+        return deleted;
+    }
+    normalize(format) {
+        const self = this;
+        const headers = {};
+        utils.forEach(this, (value, header)=>{
+            const key = utils.findKey(headers, header);
+            if (key) {
+                self[key] = normalizeValue(value);
+                delete self[header];
+                return;
+            }
+            const normalized = format ? formatHeader(header) : String(header).trim();
+            if (normalized !== header) {
+                delete self[header];
+            }
+            self[normalized] = normalizeValue(value);
+            headers[normalized] = true;
+        });
+        return this;
+    }
+    concat(...targets) {
+        return this.constructor.concat(this, ...targets);
+    }
+    toJSON(asStrings) {
+        const obj = Object.create(null);
+        utils.forEach(this, (value, header)=>{
+            value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
+        });
+        return obj;
+    }
+    [_computedKey]() {
+        return Object.entries(this.toJSON())[Symbol.iterator]();
+    }
+    toString() {
+        return Object.entries(this.toJSON()).map(([header, value])=>header + ': ' + value).join('\n');
+    }
+    get [_computedKey1]() {
+        return 'AxiosHeaders';
+    }
+    static from(thing) {
+        return thing instanceof this ? thing : new this(thing);
+    }
+    static concat(first, ...targets) {
+        const computed = new this(first);
+        targets.forEach((target)=>computed.set(target));
+        return computed;
+    }
+    static accessor(header) {
+        const internals = this[$internals] = this[$internals] = {
+            accessors: {}
+        };
+        const accessors = internals.accessors;
+        const prototype = this.prototype;
+        function defineAccessor(_header) {
+            const lHeader = normalizeHeader(_header);
+            if (!accessors[lHeader]) {
+                buildAccessors(prototype, _header);
+                accessors[lHeader] = true;
+            }
+        }
+        utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+        return this;
+    }
+};
+AxiosHeaders.accessor([
+    'Content-Type',
+    'Content-Length',
+    'Accept',
+    'Accept-Encoding',
+    'User-Agent',
+    'Authorization'
+]);
+// reserved names hotfix
+utils.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key)=>{
+    let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
+    return {
+        get: ()=>value,
+        set (headerValue) {
+            this[mapped] = headerValue;
+        }
+    };
+});
+utils.freezeMethods(AxiosHeaders);
+export default AxiosHeaders;