		'use strict'

		const { settle, createError } = require('../axios-modules')
		const statuses = require('../static/statuses')
		const getUrl = require('../core/getUrl')

		module.exports = function wxMiniprogramAdapter(config) {
		const url = getUrl(config.baseURL, config.url, config.params)

		return new Promise(function dispatchWxMiniprogramRequest(resolve, reject) {
		let request = wx.request({
		url: url,
		data: config.data,
		header: config.headers,
		timeout: typeof config.timeout === 'number' && config.timeout > 0 ? config.timeout : undefined,
		method: config.method.toUpperCase(),

		success(res) {
		const response = {
		data: res.data,
		status: res.statusCode,
		statusText: statuses[res.statusCode] \|\| 'UnKnown',
		headers: res.header,
		config,
		request,
		}
		settle(resolve, reject, response)
		},

		fail() {
		reject(createError('Network Error', config, null, request))
		request = null
		},
		})
		})
		}

+40

lib/axios-modules.js

		'use strict'

		/**
		* 当前文件用于引入原生 `axios` 的方法，所有需要使用 `axios` 源代码的方法均从此文件引入
		*
		* 说明：
		* 1. 为保持代码简略，部分方法略有修改，但未改变原意。
		*/

		function createError(message, config, code, request, response) {
		const error = new Error(message)

		error.config = config
		error.request = request
		error.response = response
		error.isAxiosError = true

		if (code) {
		error.code = code
		}

		error.toJSON = function toJSON() {
		return {
		message: this.message,
		config: this.config,
		code: this.code,
		}
		}
		}

		function settle(resolve, reject, response) {
		const validateStatus = response.config.validateStatus
		if (!response.status \|\| !validateStatus \|\| validateStatus(response.status)) {
		resolve(response)
		} else {
		reject(createError('Request failed with status code ' + response.status, response.config, null, response.request, response))
		}
		}

		module.exports = { createError, settle }

+22

lib/core/default-adapter.js

		'use strict'

		function isWxMiniprogram() {
		return typeof wx === 'object' && typeof wx.request === 'function'
		}

		/**
		* 获取默认请求适配器
		*
		* 说明：
		* 1. 仅处理附加的适配器
		* 2. `xhr` 和 `nodejs` 的适配器不处理，由 `axios` 接管
		*/
		module.exports = function getDefaultAdapter() {
		let adapter

		if (isWxMiniprogram()) {
		adapter = require('../adapters/wx-miniprogram')
		}

		return adapter
		}

+39

lib/core/params-serializer.js

		'use strict'

		function getType(val) {
		return Object.prototype.toString.call(val).slice(8, -1).toLowerCase()
		}
		/**
		* 重写 `axios` 默认的 `paramsSerializer` 方法，增加以下逻辑：
		*
		* 1. 按键名字典排序
		*/
		module.exports = function paramsSerializer(params) {
		const parts = []
		const basicType = ['number', 'string', 'boolean']

		const keys = Object.keys(params)
		keys.forEach((key) => {
		const val = params[key]
		const type = getType(val)
		if (basicType.includes(type)) {
		parts.push(`${key}=${String(val)}`)
		} else if (type === 'array') {
		val.forEach((item) => {
		if (basicType.includes(getType(item))) {
		parts.push(`${key + '[]'}=${String(item)}`)
		}
		})
		} else if (type === 'date') {
		parts.push(`${key}=${val.toISOString()}`)
		} else if (type === 'object') {
		parts.push(`${key}=${JSON.stringify(val)}`)
		} else {
		// 其余均不处理
		}
		})

		parts.sort()

		return parts.join('&')
		}

+9

lib/defaults.js

		'use strict'

		const getDefaultAdapter = require('./core/default-adapter')

		const defaults = {
		adapter: getDefaultAdapter(),
		}

		module.exports = defaults

+148

lib/interceptors/aliyun-apigw-signature.js

		'use strict'

		const CryptoJS = require('crypto-js')
		const getUrl = require('../core/getUrl')

		/** 放在 `config.headers` 中但是非正常请求头字段的字段 */
		const axiosExtHeader = ['common', 'delete', 'get', 'head', 'patch', 'post', 'put']

		/**
		* 规格化请求头
		* 1. 将字段名变为小写
		* 2. 去除重复的字段
		*/
		function normalizeHeaders(headers) {
		if (typeof headers !== 'object') {
		return {}
		} else {
		return Object.keys(headers).reduce((result, field) => {
		console.log('field: ', field)
		const lowerField = field.toLowerCase()
		if (!result[lowerField] && headers[field] && !axiosExtHeader.includes(field)) {
		result[lowerField] = headers[field]
		}
		return result
		}, {})
		}
		}

		/**
		* 获取参与签名的请求头字段
		* @param {object} headers 请求头
		* @returns {string[]}
		*/
		function getSignHeaderKeys(headers) {
		/** 不参与 Header 签名的请求头 */
		const EXCLUDE_SIGN_HEADERS = ['x-ca-signature', 'x-xa-signature-headers', 'accept', 'content-md5', 'content-type', 'date']

		const signHeaderKeys = []
		Object.keys(headers).forEach((field) => {
		if (!EXCLUDE_SIGN_HEADERS.includes(field)) {
		signHeaderKeys.push(field)
		}
		})

		return signHeaderKeys.sort()
		}

		function getSignedHeadersString(signHeaderKeys, headers) {
		const list = []
		for (let i = 0; i < signHeaderKeys.length; i++) {
		const key = signHeaderKeys[i]
		const value = headers[key]
		list.push(key + ':' + (value ? value : ''))
		}
		return list.join('\n')
		}

		function getPathAndParams(url) {
		const urlRaw = url.replace('https://', '').replace('http://', '')
		return urlRaw.substr(urlRaw.indexOf('/'))
		}

		function md5(content) {
		return CryptoJS.MD5(content).toString(CryptoJS.enc.Base64)
		}

		function buildStringToSign(method, headers, signedHeadersString, pathAndParams) {
		const lf = '\n'
		const list = [method.toUpperCase(), lf]

		const arr = ['accept', 'content-md5', 'content-type', 'date']
		for (let i = 0; i < arr.length; i++) {
		const key = arr[i]
		if (headers[key]) {
		list.push(headers[key])
		}
		list.push(lf)
		}

		if (signedHeadersString) {
		list.push(signedHeadersString)
		list.push(lf)
		}

		if (pathAndParams) {
		list.push(pathAndParams)
		}

		return list.join('')
		}

		/**
		* 阿里云 API 网关签名加密
		* @see https://help.aliyun.com/document_detail/29475.html
		*/
		module.exports = function aliyunApigwSignatureInterceptor(config) {
		// 未配置签名参数，则直接跳过
		if (typeof config.signature !== 'object') {
		return config
		}

		const { key, secret, debug } = config.signature

		if (!(key && secret)) {
		throw new Error('配置了 `signature` 参数但是未配置 `key` 或 `secret`')
		}

		const headers = normalizeHeaders(config.headers)

		// 给请求头添加一些要求添加的字段
		headers['x-ca-key'] = key
		headers['x-ca-timestamp'] = Date.now()
		headers['accept'] = headers['accept'] \|\| '/'
		headers['content-type'] = headers['content-type'] \|\| 'application/json'

		// 该请求头要求为一个随机字符串，理论上使用 `UUID` 更好，为了少引入依赖，使用这种方法
		headers['x-ca-nonce'] = CryptoJS.MD5(Date.now().toString() + Math.random() * 10000).toString(CryptoJS.enc.Hex)

		/** 允许包含 `body` 的请求方法 */
		const bodyValidMethod = ['post', 'put', 'patch']
		if (bodyValidMethod.includes(config.method.toLowerCase())) {
		if (config.data) {
		headers['content-md5'] = md5(JSON.stringify(config.data))
		} else {
		console.warn(`当前请求方法为 \`${config.method}\` 但是未配置请求数据（\`data\`）`)
		}
		} else {
		if (config.data) {
		console.warn('如果要提交请求数据 `data`，请使用以下请求方法：`post`, `put`, `patch` ')
		}
		}

		const signHeaderKeys = getSignHeaderKeys(headers)
		headers['x-ca-signature-headers'] = signHeaderKeys.join(',')

		const url = getUrl(config.baseURL, config.url, config.params)
		const pathAndParams = getPathAndParams(url)
		const signedHeadersString = getSignedHeadersString(signHeaderKeys, headers)
		const stringToSign = buildStringToSign(config.method, headers, signedHeadersString, pathAndParams)
		headers['x-ca-signature'] = CryptoJS.HmacSHA256(stringToSign, secret).toString(CryptoJS.enc.Base64)

		if (debug) {
		console.info(`当前签名字符串：\`${stringToSign.replace(/\n/g, '#')}\``)
		}

		config.headers = headers
		return config
		}

+25

lib/interceptors/core-interceptor.js

		'use strict'

		const getDefaultAdapter = require('../core/default-adapter')
		const mockAdapter = require('../adapters/mock')

		module.exports = function coreInterceptor(config) {
		/**
		* 处理 `mock` 参数，优先级高于 `adapter` 参数
		*
		* 说明：
		* 1. 只要存在有效的 `mock` 参数，则挂载 `mockAdapter` 适配器
		*/
		if (typeof config.mock === 'object' && Object.keys(config.mock).length > 0) {
		config.adapter = mockAdapter
		}

		/**
		* `adapter` 参数为空，则挂载对应的请求适配器
		*/
		if (!config.adapter) {
		config.adapter = getDefaultAdapter()
		}

		return config
		}

+4

-0

CHANGELOG.md

		# 版本更新说明

		## v0.5.0 - 2021.06.18

		1. 重构版本

		## v0.4.1 - 2021.05.07
		@@ -4,0 +8,0 @@

+2

-1

index.js

		'use strict'

		const jshttp = require('./lib/jshttp.js')
		const jshttp = require('./lib/jshttp')

		module.exports = jshttp
		@@ -5,0 +6,0 @@

+48

-13

lib/adapters/mock.js

		'use strict'

		const { settle, createError } = require('../axios-modules')
		const statuses = require('../static/statuses')

		/**
		* 用于 Mock 数据，未发送真实请求
		* 用于客户端 Mock 请求数据，并未发送真实的 HTTP 请求。
		*/

		/** 文档地址 */
		const docUrl = 'https://www.npmjs.com/package/jshttp#使用'

		module.exports = function mockAdapter(config) {
		@@ -11,21 +17,50 @@ const { mock } = config
		if (typeof mock !== 'object') {
		throw new Error(`配置项 \`mock\` 要求是一个 \`object\` 类型的值，但是你设置的 \`mock\` = \`${mock}\` 为 \`${typeof mock}\` 类型`)
		throw new Error(`配置项 \`mock\` 要求是一个 \`object\` 类型的值，详情请查看文档 ${docUrl}`)
		}

		const { status, statusText, headers, data, error } = mock
		// 处理参数，所有参数均为选填
		const status = mock.status \|\| 200
		const statusText = mock.statusText \|\| statuses[status] \|\| 'UnKnown'
		const headers = mock.headers \|\| {}
		const data = mock.data
		const delay = (mock.delay && parseInt(mock.delay, 10)) \|\| 1
		const error = mock.error

		return new Promise((resolve, reject) => {
		/** 各个平台的 `request` 均不同，这个无法模拟，只能模拟一些基础属性 */
		let request = mock.request \|\| {
		method: config.method,
		headers: config.headers,
		data: config.data,
		}

		// 超时时间，用于模拟请求超时
		const timeout = config.timeout \|\| 0

		return new Promise(function dispatchMockRequest(resolve, reject) {
		/** 请求是否完成 */
		let isRequestFinished = false

		// 模拟请求超时的 `ontimeout` 事件
		if (timeout > 0) {
		setTimeout(() => {
		if (!isRequestFinished) {
		const timeoutErrorMessage = config.timeoutErrorMessage \|\| `timeout of ${timeout} ms exceeded`
		reject(createError(timeoutErrorMessage, config, 'ECONNABORTED', request))
		request = null
		}
		}, timeout)
		}

		// 模拟正常请求流程
		setTimeout(() => {
		isRequestFinished = true

		if (error) {
		reject(new Error(error))
		// 模拟发生错误的 `onerror` 事件
		reject(createError('Network Error', config, null, request))
		request = null
		} else {
		resolve({
		status: status \|\| 200,
		statusText: statusText \|\| '',
		headers: headers \|\| {},
		data: data,
		config: config,
		request: Object.create(null),
		})
		// 请求成功情况
		const response = { data, status, statusText, headers, config, request }
		settle(resolve, reject, response)
		}
		@@ -32,0 +67,0 @@ }, delay)

+3

-11

lib/core/getUrl.js

		'use strict'

		const paramsSerializer = require('./params-serializer')

		function isHttpUrl(url) {
		@@ -45,13 +47,3 @@ if (url && typeof url === 'string' && (url.startsWith('http://') \|\| url.startsWith('https://'))) {
		function encodeQs(obj) {
		const arr = []
		Object.keys(obj)
		.sort()
		.forEach((name) => {
		const value = obj[name].toString()
		if (value && typeof value === 'string' && value !== '[object Object]') {
		// 兼容数组，name=['a','b'] 会转变为 name=a,b
		arr.push(`${name}=${value}`)
		}
		})
		return arr.join('&')
		return paramsSerializer(obj)
		}
		@@ -58,0 +50,0 @@

+13

-20

lib/jshttp.js

		'use strict'

		const Application = require('./core/applocation.js')
		const getDefaults = require('./config/defaults.js')
		const axios = require('axios')
		const defaults = require('./defaults')
		const coreInterceptor = require('./interceptors/core-interceptor')
		const aliyunApigwSignatureInterceptor = require('./interceptors/aliyun-apigw-signature')

		function createInstance(defaultConfig) {
		const instance = new Application(defaultConfig)
		function create(defaultConfig) {
		const instance = axios.create(defaultConfig)
		instance.interceptors.request.use(aliyunApigwSignatureInterceptor)
		instance.interceptors.request.use(coreInterceptor)
		return instance
		}

		function request(...args) {
		return instance.request(...args)
		}
		const jshttp = create(defaults)
		jshttp.create = create

		// 挂载常用方法
		const methods = ['get', 'post', 'delete', 'put', 'patch']
		methods.forEach((method) => {
		request[method] = function (...args) {
		return request(method.toUpperCase(), ...args)
		}
		})

		return request
		}

		module.exports = createInstance(getDefaults())
		module.exports.create = createInstance
		module.exports = jshttp

+0

-0

lib/static/statuses.js

@@ -0,0 +0,0 @@ 'use strict'

+0

-0

LICENSE

@@ -0,0 +0,0 @@ MIT License

+7

-2

package.json

		{
		"name": "jshttp",
		"version": "0.4.2",
		"description": "能在任何 Javascript 环境使用的 HTTP 请求库，支持 Node.js，浏览器，微信小程序，支付宝小程序，百度小程序 ...",
		"version": "0.5.0",
		"description": "基于 Axios 的 HTTP 请求库，内置了一些常用功能，支持在任何 Javascript 环境下运行",
		"main": "index.js",
		@@ -14,2 +14,3 @@ "scripts": {
		"keywords": [
		"axios",
		"request",
		@@ -30,3 +31,7 @@ "http",
		"mocha": "^8.4.0"
		},
		"dependencies": {
		"axios": "^0.21.1",
		"crypto-js": "^4.0.0"
		}
		}

+6

-167

README.md

		@@ -16,3 +16,3 @@ # jshttp

		`JsHttp` 是一个基于 `Promise` 的 `Javascript` HTTP 请求库，支持在任何 `Javascript` 环境中发起 HTTP 请求（目前已支持 `Node.js`，`浏览器`，各大平台小程序，包含`微信`、`QQ`、`支付宝`、`字节跳动`等平台），在各个环境提供完全一致 `API`。同时集成了强大的中间件功能，可以自由灵活地对请求和响应进行操作。
		`JsHttp` 是一个基于 `Axios` 的 `Javascript` HTTP 请求库，支持在任何 `Javascript` 环境中发起 HTTP 请求（目前已支持 `Node.js`，`浏览器`，各大平台小程序，包含`微信`、`QQ`、`支付宝`、`字节跳动`等平台），在各个环境提供完全一致 `API`。

		@@ -31,11 +31,2 @@ ## 目录
		- [配置项](#配置项)
		- [进阶](#进阶)
		- [默认值](#默认值)
		- [设置默认值的方式](#设置默认值的方式)
		- [默认值合并方式](#默认值合并方式)
		- [中间件](#中间件)
		- [中间件简介](#中间件简介)
		- [中间件实现](#中间件实现)
		- [使用中间件](#使用中间件)
		- [中间件顺序](#中间件顺序)
		- [作者](#作者)
		@@ -51,2 +42,4 @@ - [参与](#参与)

		另外，常用的 HTTP 请求库 `Axios` 本身已经非常成熟了，因此笔者基于 `Axios` 进行开发，拓展了 `Axios` 原生的 `adapter` 和 `interceptor` 来完成对应功能。

		### 特点
		@@ -57,6 +50,5 @@
		1. 支持所有的 `Javascript` 环境（也就是说，只要你在用 `Javascript` 写代码，你可以可以使用 `JsHttp` 来发起请求）。
		2. 兼容 `Axios` 参数，可以从 `Axios` 无缝迁移到 `JsHttp`。
		3. 强大的中间件功能，可以非常方便灵活地操作请求和响应（中间件逻辑参考了 `Koa`，特此说明）。
		4. 内置了一些中间件，例如请求内容签名、格式转换等，进行简单配置后就可以直接使用。
		5. 全中文错误提示，更利于开发和调试。
		2. 完全兼容 `Axios` 参数，可以从 `Axios` 无缝迁移到 `JsHttp`。
		3. 内置了一些中间件，例如请求内容签名、格式转换等，进行简单配置后就可以直接使用。
		4. 全中文错误提示，更利于开发和调试。

		@@ -319,155 +311,2 @@ ## 安装

		## 进阶

		### 默认值

		#### 设置默认值的方式

		在实际开发中，你可能会希望自定义一些默认值，例如往往后端请求地址是固定的，不希望每次请求时都配置 `baseURL`，你希望能够将其设定为全局的默认值，`jshttp` 提供了两种方式来修改默认值。

		比较简单的方式为直接修改 `jshttp.defaults[attribute]` 的值，例如：

		```javascript
		jshttp.defaults.baseURL = 'https://api.inlym.com/
		```

		其他的配置项也可以用同样的方式去设置。

		另一种更为复杂的情况是，在一个前端项目中，需要配置多套不同的默认值，这种情况建议使用 `jshttp.create(defaultConfig)` 方法去创建一个新的实例，例如：

		```javascript
		const request1 = jshttp.create({
		baseURL: 'https://api1.inlym.com',
		responseType: 'text',
		})

		const request2 = jshttp.create({
		baseURL: 'https://api2.inlym.com',
		responseType: 'text',
		timeout: 2000,
		})
		```

		对于通过以上方式创建的 `request1` 和 `request2`，你可以像使用 `jshttp` 一样去使用它们。

		#### 默认值合并方式

		实际上，存在 3 组配置项：

		1. `jshttp` 内置的全局默认值
		2. 实例的自定义默认值
		3. 本次请求的配置项

		3 组配置项的优先级由低到高，在发起请求前会将配置项合并，生成最终的请求配置项，但实际上，各个配置项的合并方式还有有一些不一样的，对于除 `headers` 和 `params` 以外的其他配置项，更高优先级直接覆盖低优先级中的配置项。

		对于 `headers` 和 `params` 这 2 个配置项，合并方式略有不同，采用合并而不是覆盖（对象内同名字段采用覆盖），例如：

		```javascript
		jshttp.defaults.headers = {
		'header-a': 'aaa',
		'header-b': 'bbb',
		}

		const config = {
		headers: {
		'header-b': 'BBB',
		'header-c': 'ccc',
		}
		}

		// 使用 `jshttp(config)` 发起请求时，实际合成的 `headers` 为
		{
		'header-a': 'aaa',
		'header-b': 'BBB',
		'header-c': 'ccc',
		}
		```

		### 中间件

		#### 中间件简介

		`jshttp` 的中间件是与 `Axios` 的中间件采用了完全不同的实现方式，在实现逻辑上借鉴了 `Koa` 的中间件实现方式，你可以将其称之为洋葱模型。在 `ctx` 变量上挂载了以下对象：

		1. `config` - 配置项
		2. `adapter` - 请求适配器
		3. `response` - 响应（在适配器发送请求成功后创建）

		你可以通过操作以上挂载的变量来实现中间件功能，中间件函数既可以是一个标准的异步函数，也可以是同步函数（会被封装为异步函数）。

		#### 中间件实现

		下面演示几个中间件实现。

		示例 1：（模拟常见的请求签名逻辑）对 `headers` 签名，并使用 `x-ca-signature-headers` 字段记录被签名的字段，使用 `x-ca-signature` 记录签名内容：

		```javascript
		// 备注：只是用来演示中间件写法，并不是严谨的签名实现方法
		function sign(ctx) {
		// 从 `ctx` 中获取 `headers`
		const requestHeaders = ctx.config.headers

		const fields = Object.keys(requestHeaders)
		const valueList = fields.map((field) => {
		return requestHeaders[field]
		})

		requestHeaders['x-ca-signature-headers'] = fields.join(',')
		requestHeaders['x-ca-signature'] = md5(valueList.join('\n'))
		}
		```

		示例 2：微信小程序请求查询字符串加上 `code` 作为鉴权方式

		```javascript
		// 第一步：封装获取 `code` 的方法为 `Promise`
		function getCode() {
		return new Promise((resolve) => {
		wx.login({
		success(res) {
		resolve(res.code)
		},
		})
		})
		}

		// 第二步：在中间件中使用，需要用到 `await`
		async function appendCode(ctx, next) {
		const code = await getCode()
		ctx.config.params.code = code
		await next()
		}
		```

		#### 使用中间件

		中间件的配置和其他配置项一样，既可以定义为默认配置项，也可以只放在本次请求中使用。

		使用方式 1：仅在本次请求中使用中间件，在配置项 `middleware` 中设置就行了

		```javascript
		jshttp({
		// ... 其他配置项
		middleware: [appendCode, sign],
		})
		```

		使用方式 2：添加到默认配置项

		`middleware` 配置项定义为默认配置项的方式和其他参数完全一致，除此之外，还可以使用 `jshttp.use(fn)` 方法添加一个新的中间件到中间件列表中（本质上只是对列表进行了一个 `push` 操作）

		#### 中间件顺序

		少数中间件对于执行顺序是有要求的，例如签名中间件就应该放在所有的中间件之后，在发送请求之前，`jshttp` 内置提供了定义中间件执行顺序的方法，在以上说明的任何放置中间件的地方，可以替换为以下对象，定义中间件顺序：

		```javascript
		// 以上述的 `sign` 中间件为例
		{
		fn: sign,
		order: 9999,
		}
		```

		使用普通方式添加中间件或者未定义 `order` 参数的中间件，将自动将 `order` 设置为 `100`，最终会将所有中间件按 `order` 升序执行。

		## 作者
		@@ -474,0 +313,0 @@

-121

lib/adapters/mini-base.js

		'use strict'

		/**
		* 生成一个小程序适配器
		* @param {object} options 构造适配器的配置项
		*
		* 说明：
		* 1. 由于平台的小程序的 `request` 方法大同小异，因此没必要各个单独写，只需要兼容一下参数就可以了
		* 2. 适配参数，然后输出一个函数
		*
		* 小程序平台：
		* 1. 微信小程序
		* @see https://developers.weixin.qq.com/miniprogram/dev/api/network/request/wx.request.html
		*
		* 2. QQ 小程序
		* @see https://q.qq.com/wiki/develop/miniprogram/API/network/network_request.html
		*
		* 3. 支付宝小程序
		* @see https://opendocs.alipay.com/mini/api/owycmh
		*
		* 4. 字节跳动小程序
		* @see https://microapp.bytedance.com/docs/zh-CN/mini-app/develop/api/network/http/tt-request
		*/

		const getUrl = require('../core/getUrl.js')

		/**
		* 将配置项中的 `responseType` 参数转换为小程序请求所需的 `dataType` 和 `dataType` 参数
		* @param {string} responseType 响应数据类型
		*/
		function convertResponseType(responseType) {
		if (typeof my === 'object') {
		if (responseType === undefined \|\| responseType === 'json') {
		return { dataType: 'JSON' }
		} else {
		return { dataType: responseType }
		}
		} else {
		if (responseType === undefined \|\| responseType === 'json') {
		return {
		dataType: 'json',
		responseType: 'text',
		}
		} else if (['arraybuffer', 'blob', 'stream'].includes(responseType)) {
		return {
		dataType: 'arraybuffer',
		responseType: 'arraybuffer',
		}
		} else {
		return {
		dataType: 'string',
		responseType: 'text',
		}
		}
		}
		}

		module.exports = function createMiniAdapter(options) {
		/** 请求头字段名称，默认 `headers` */
		const requestHeaders = (options.alias && options.alias.requestHeaders) \|\| 'headers'

		/** 响应头字段名称，默认 `headers` */
		const responseHeaders = (options.alias && options.alias.responseHeaders) \|\| 'headers'

		/** 响应码字段名称，默认 `statusCode` */
		const statusCode = (options.alias && options.alias.statusCode) \|\| 'statusCode'

		return function miniAdapter(config) {
		const requestOptions = {
		method: config.method,
		url: getUrl(config.baseURL, config.url, config.params),
		timeout: config.timeout,
		[requestHeaders]: config.headers,
		}

		/** 不应该有请求体的请求方法 */
		const NO_BODY_METHODS = ['GET', 'HEAD', 'OPTIONS']
		if (!NO_BODY_METHODS.includes(config.method) && config !== undefined) {
		requestOptions.data = config.data
		}

		/**
		* 备注：
		* 笔者认为，当请求方法为 `GET` 时，将 `data` 插入到 `quertstirng` 中，这种做法很怪异！非常容易造成难以预料的问题！
		* 因此在 `jshttp` 中，直接屏蔽了这种做法。
		*/

		/** 附加的参数 */
		const extraConfigKeys = ['enableHttp2', 'enableQuic', 'enableCache']
		extraConfigKeys.forEach((key) => {
		if (config[key]) {
		requestOptions[key] = config[key]
		}
		})

		return new Promise((resolve, reject) => {
		const request = options.platform.request(
		Object.assign({}, convertResponseType(config.responseType), requestOptions, {
		success(res) {
		resolve({
		status: res[statusCode],
		headers: res[responseHeaders],
		data: res.data,
		config: config,
		request: request,
		})
		},
		fail(res) {
		if (!res) {
		reject(new Error('请求错误，发起请求失败！'))
		} else {
		if (typeof res === 'object' && typeof res.errMsg === 'string') {
		reject(new Error('请求失败，错误原因：' + res.errMsg))
		}
		}
		},
		})
		)
		})
		}
		}

-28

lib/adapters/mini-my.js

		'use strict'

		/**
		* 支付宝小程序
		* @see https://opendocs.alipay.com/mini/api/owycmh
		*/

		const createMiniAdapter = require('./mini-base.js')

		const options = {
		/** 所在平台简称 */
		name: 'my',

		/** 对应的全局变量 */
		platform: my,

		/** 支持的请求方法 */
		methods: ['GET', 'POST', 'PUT', 'DELETE'],

		/** 参数别名 */
		alias: {
		requestHeaders: 'headers',
		responseHeaders: 'headers',
		statusCode: 'status',
		},
		}

		module.exports = createMiniAdapter(options)

-28

lib/adapters/mini-qq.js

		'use strict'

		/**
		* QQ 小程序
		* @see https://q.qq.com/wiki/develop/miniprogram/API/network/network_request.html
		*/

		const createMiniAdapter = require('./mini-base.js')

		const options = {
		/** 所在平台简称 */
		name: 'qq',

		/** 对应的全局变量 */
		platform: qq,

		/** 支持的请求方法 */
		methods: ['OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE', 'CONNECT'],

		/** 参数别名 */
		alias: {
		requestHeaders: 'header',
		responseHeaders: 'header',
		statusCode: 'statusCode',
		},
		}

		module.exports = createMiniAdapter(options)

-32

lib/adapters/mini-tt.js

		'use strict'

		/**
		* 字节跳动小程序
		* @see https://microapp.bytedance.com/docs/zh-CN/mini-app/develop/api/network/http/tt-request
		*/

		const createMiniAdapter = require('./mini-base.js')

		const options = {
		/** 所在平台简称 */
		name: 'tt',

		/** 对应的全局变量 */
		platform: tt,

		/** 支持的请求方法
		*
		*
		* GET/POST/OPTIONS/PUT/HEAD/DELETE
		*/
		methods: ['GET', 'HEAD', 'POST', 'OPTIONS', 'PUT', 'DELETE'],

		/** 参数别名 */
		alias: {
		requestHeaders: 'header',
		responseHeaders: 'header',
		statusCode: 'statusCode',
		},
		}

		module.exports = createMiniAdapter(options)

-23

lib/adapters/mini-wx.js

		'use strict'

		const createMiniAdapter = require('./mini-base.js')

		const options = {
		/** 所在平台简称 */
		name: 'wx',

		/** 对应的全局变量 */
		platform: wx,

		/** 支持的请求方法 */
		methods: ['OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE', 'CONNECT'],

		/** 参数别名 */
		alias: {
		requestHeaders: 'header',
		responseHeaders: 'header',
		statusCode: 'statusCode',
		},
		}

		module.exports = createMiniAdapter(options)

-108

lib/adapters/node.js

		'use strict'

		/**
		* Node.js HTTP
		* @see https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_http_request_options_callback
		*/

		const http = require('http')
		const https = require('https')
		const getUrl = require('../core/getUrl.js')
		const packageInfo = require('../../package.json')

		/**
		* Node.js 发起请求适配器
		* @param {object} config 配置项
		*
		* 说明：
		* 1. 本期版本统一不支持 proxy
		* 2. 后续版本支持自定义 agent
		*/
		module.exports = function nodeAdapter(config) {
		const url = getUrl(config.baseURL, config.url, config.params)

		// 根据 `http` 或 `https` 协议选用对应的模块
		let httpModule = null
		if (url.startsWith('http://')) {
		httpModule = http
		} else if (url.startsWith('https://')) {
		httpModule = https
		} else {
		throw new Error('请求地址请以 `http://` 或 `https://` 开头！')
		}

		const { headers, method } = config

		// 处理 `data`
		let requestData = null
		let contentType = ''
		if (typeof config.data === 'object') {
		requestData = JSON.stringify(config.data)
		contentType = 'application/json'
		} else if (typeof config.data === 'string') {
		requestData = config.data
		contentType = 'text/plain'
		}

		const options = {
		method: method,
		headers: headers,
		}

		if (config.timeout && config.timeout > 0) {
		options.timeout = config.timeout
		}

		return new Promise((resolve, reject) => {
		const request = httpModule.request(url, options, function handleResponse(response) {
		const responseBufferList = []

		response.on('data', function handleResponseData(buf) {
		responseBufferList.push(buf)
		})

		response.on('end', function handleResponseEnd() {
		let responseData = Buffer.concat(responseBufferList)
		if (config.responseType !== 'arraybuffer') {
		responseData = responseData.toString(config.responseEncoding)
		}
		resolve({
		status: response.statusCode,
		statusText: response.statusMessage,
		headers: response.headers,
		data: responseData,
		config: config,
		request: request,
		})
		})
		})

		// 监听 `error` 事件
		request.on('error', function handleRequestError(err) {
		reject(new Error(`请求时发生错误，触发 \`error\` 事件，以下是错误原因：${err}`))
		})

		request.on('timeout', function handleRequestTimeout() {
		/**
		* 请求超时时，需要手动中止请求
		* @see https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_event_timeout
		*
		* `request.abort()` 方法已启用，改用 `request.destroy()`
		* @see https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_request_abort
		*/
		request.destroy()
		reject(new Error(`请求已超时(你设置的超时时间为 \`timeout: ${config.timeout}\`，单位：ms)`))
		})

		// 附加一些请求头
		if (!request.getHeader('User-Agent')) {
		request.setHeader('User-Agent', `JsHttp/${packageInfo.version}`)
		}

		if (!request.getHeader('Content-Type') && contentType) {
		request.setHeader('Content-Type', contentType)
		}

		request.end(requestData)
		})
		}

-177

lib/adapters/xhr.js

		'use strict'

		const getUrl = require('../core/getUrl.js')

		/**
		* XMLHttpRequest
		* @see https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest
		*/

		/**
		* 获取并解析响应头
		* @param {XMLHttpRequest} xhr
		* @returns {object} 解析成对象的响应头
		*
		* 调用 `XMLHttpRequest.getAllResponseHeaders()` 获取的响应头，是以 `CRLF` 分割的字符串，需要手工解析
		* @see https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest/getAllResponseHeaders
		*/
		function getHeaders(xhr) {
		/**
		* 关于 `CRLF`
		* @see https://developer.mozilla.org/zh-CN/docs/Glossary/CRLF
		*/
		const CRLF = '\r\n'

		// 裸响应头，以 `CRLF` 分割的字符串
		const rawHeaders = xhr.getAllResponseHeaders()

		// 以分隔符拆分响应头字符串
		const headerList = rawHeaders.split(CRLF)

		// 获取响应头字段名列表
		const fieldList = headerList.map((v) => {
		return v.split(':')[0]
		})

		const headers = {}
		fieldList.forEach((field) => {
		if (field) {
		headers[field] = xhr.getResponseHeader(field)
		}
		})
		return headers
		}

		/**
		* 检查指定请求头是否被禁用修改（仅提示）
		* @param {string} field 请求头字段（请求首部）
		*
		* 部分请求头不能在代码中通过编程的方式进行修改，应该由由浏览器控制
		* @see https://developer.mozilla.org/zh-CN/docs/Glossary/Forbidden_header_name
		*/
		function warnIfHeaderNameForbidden(field) {
		const forbiddenHeaderNames = [
		'Accept-Charset',
		'Accept-Encoding',
		'Access-Control-Request-Headers',
		'Access-Control-Request-Method',
		'Connection',
		'Content-Length',
		'Cookie',
		'Cookie2',
		'Date',
		'DNT',
		'Expect',
		'Host',
		'Keep-Alive',
		'Origin',
		'Referer',
		'TE',
		'Trailer',
		'Transfer-Encoding',
		'Upgrade',
		'Via',
		]

		const forbiddenHeaderNamePrefix = ['Proxy-', 'Sec-']

		forbiddenHeaderNames.forEach((key) => {
		if (key.toUpperCase() === field.toUpperCase()) {
		const message = `请求头 \`${field}\` 不允许自主设置，应当由浏览器自动设置，建议删除该请求头！详见文档 https://developer.mozilla.org/zh-CN/docs/Glossary/Forbidden_header_name`
		console.error(message)
		}
		})

		forbiddenHeaderNamePrefix.forEach((pre) => {
		if (field.toUpperCase().startsWith(pre.toUpperCase())) {
		const message = `以 \`${pre}\` 开头的请求头不允许自主设置，应当由浏览器自动设置，建议删除 \`${field}\` 请求头！详见文档 https://developer.mozilla.org/zh-CN/docs/Glossary/Forbidden_header_name`
		console.error(message)
		}
		})
		}

		/**
		* 检查响应数据类型（即 `responseType` 值）是否合规
		* @param {string} responseType 响应数据的类型
		*
		* @see https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest/responseType
		*/
		function throwErrorIfInvalidResponseType(responseType) {
		const valid = ['', 'arraybuffer', 'blob', 'document', 'json', 'text']
		if (!valid.includes(responseType)) {
		throw new Error(`你设置的 \`responseType\` 为 \`${responseType}\` 不是一个有效的值！`)
		}
		}

		module.exports = function xhrAdapter(config) {
		const url = getUrl(config.baseURL, config.url, config.params)

		return new Promise((resolve, reject) => {
		const xhr = new XMLHttpRequest()
		xhr.open(config.method, url, true)

		// 设置超时时间
		if (config.timeout > 0) {
		xhr.timeout = config.timeout
		}

		// 设置响应值类型
		throwErrorIfInvalidResponseType(config.responseType)
		xhr.responseType = config.responseType

		// 设置 `withCredentials`
		if (config.withCredentials) {
		xhr.withCredentials = true
		}

		// 监听发生请求错误
		xhr.onerror = function handleRequestError() {
		reject(new Error('请求时发生错误，触发 `error` 事件'))
		}

		/**
		* 监听请求完成，`onload` 相比 `onreadystatechange` 更智能一些
		* @see https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequestEventTarget/onload
		*/
		xhr.onload = function handleRequestLoad() {
		const responseHeaders = getHeaders(xhr)

		resolve({
		status: xhr.status,
		statusText: xhr.statusText,
		headers: responseHeaders,
		data: xhr.response,
		config: config,
		request: xhr,
		})
		}

		// 监听请求超时
		xhr.ontimeout = function handleRequestTimeout() {
		reject(new Error(`请求已超时(你设置的超时时间为 \`timeout: ${config.timeout}\`，单位：ms)`))
		}

		// 处理请求数据
		let requestData = config.data \|\| null

		/**
		* 如果请求方法是 GET 或者 HEAD，则应将请求主体设置为 null
		* @see https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest/send
		*/
		if (['GET', 'HEAD'].includes(config.method)) {
		requestData = null
		}

		if (requestData && typeof requestData === 'object') {
		requestData = JSON.stringify(requestData)
		}

		// 最终处理请求头，逐个设置
		Object.keys(config.headers).forEach((field) => {
		warnIfHeaderNameForbidden(field)
		xhr.setRequestHeader(field, config.headers[field])
		})

		xhr.send(requestData)
		})
		}

-36

lib/config/buildConfig.js

		'use strict'

		const methods = require('../static/methods.js')

		/**
		* 支持不定长度的参数形式，合成一个参数对象
		*
		* 格式演示：
		* 1. `('get', '/path.to?name=mark', { baseURL: 'https://www.jshttp.com' })`
		* 2. `('/path.to?name=mark')`
		* 3. `({ baseURL: 'https://www.jshttp.com', method: 'post'})`
		* 4. `({ baseURL: 'https://www.jshttp.com' }, 'get', '/path.to?name=mark',)`
		*/
		module.exports = function buildConfig(...args) {
		if (args.length === 0) {
		throw new Error('请求配置项 `config` 不能为空')
		}

		// 首先生成一个对象列表
		const configList = args.map((value) => {
		if (typeof value === 'object' && value !== null) {
		return value
		} else if (typeof value === 'string') {
		if (methods.includes(value.toUpperCase())) {
		return { method: value.toUpperCase() }
		} else {
		return { url: value }
		}
		}
		})

		const config = {}
		Object.assign(config, ...configList)

		return config
		}

-192

lib/config/defaults.js

		'use strict'

		const getAdapter = require('../core/getAdapter.js')
		const defaultAdapter = getAdapter()

		/**
		* 当前文件放置 [ 默认配置 ]
		*
		* 用途说明：
		* 1. 生成实例时，作为默认配置
		* 2. 开发者可以从当前文件查看支持的参数，以及含义
		* 3. 未避免全局污染，封装为函数
		*/
		module.exports = function getDefaults() {
		return {
		/********************************* 基本类型值配置 ********************************/

		/**
		* 请求方法
		*
		* 常用值：
		* 1. `GET`
		* 2. `POST`
		* 3. `PUT`
		* 4. `DELETE`
		* 5. `HEAD`
		*/
		method: 'GET',

		/**
		* 请求基础地址
		*
		* 说明：
		* 1. 不为空时要求以 `http://` 或 `https://` 开头
		* 2. 配置项 `url` 以 `http://` 或 `https://` 开头时，配置项 `baseURL` 无效
		* 3. 配置项 `url` 为普通路径时（即以非 `http://` 或 `https://` 开头），将两者连接合成请求地址
		*/
		baseURL: undefined,

		/**
		* 请求地址
		*
		* 说明：
		* 1. 可单独存在，或者和 `baseURL` 拼接合成请求地址
		* 2. 和 `baseURL` 不能同时为空
		*/
		url: undefined,

		/**
		* 请求的数据类型
		*
		* 合法值：
		* 1. `json`
		* 2. `text`
		* 3. `form`
		* 4. `arraybuffer`
		*/
		requestType: 'json',

		/**
		* 响应的数据类型
		*
		* 合法值：
		* 1. `json` - 全部适用
		* 2. `arraybuffer` - 全部适用
		* 3. `text` - 全部适用
		* 4. `blob` - 仅用于 `XMLHttpRequest`
		* 5. `document` - 仅用于 `XMLHttpRequest`
		* 6. `stream` - 仅用于 `Node.js`
		*/
		responseType: 'json',

		/**
		* 响应的字符编码
		*
		* 合法值：
		* 'utf8', 'utf-8', 'utf16le', 'latin1', 'base64', 'hex', 'ascii', 'binary', 'ucs2'
		*/
		responseEncoding: 'utf8',

		/**
		* 请求超时时间
		*
		* 说明：
		* 1. `0` 表示无超时时间
		* 2. 单位：毫秒（ms）
		*/
		timeout: 0,

		/**
		* 重试次数
		*
		* 说明：
		* 1. `0` 表示不重试
		*/
		retry: 0,

		/**
		* 是否开启调试模式
		*
		* 开启后，包含以下功能：
		* 1. 打印请求日志
		*/
		debug: false,

		/**
		* 用于打印日志的函数
		* @param {object} content 日志内容对象
		* @param {number} content.status 响应状态码
		* @param {string} content.url 请求地址
		* @param {object} content.config 配置项
		* @param {number} content.startTime 发起请求任务时间（时间戳）
		* @param {number} content.endTime 结束请求任务时间（时间戳）
		* @param {number} content.requestTime 本次发起请求时间（时间戳）
		* @param {number} content.responseTime 本次结束响应时间（时间戳）
		* @param {string} content.startTimeText 发起请求任务时间（文本格式）
		* @param {string} content.endTimeText 结束请求任务时间（文本格式）
		* @param {string} content.requestTimeText 本次发起请求时间（文本格式）
		* @param {string} content.responseTimeText 本次结束响应时间（文本格式）
		*/
		logging: function logging(content) {
		const message = `${content.startTimeText} ${content.responseTime - content.requestTime}ms ${content.config.method} ${content.url} ${content.status}`
		console.log(message)
		},

		/********************************* 对象类配置 ********************************/

		/**
		* 请求头
		*/
		headers: {},

		/**
		* 请求参数，最终以 `name=mark&age=19` 的形式合并到 `url` 中
		*/
		params: {},

		/**
		* mock 响应对象
		*/
		mock: undefined,

		/********************************* 函数类配置 ********************************/

		/**
		* 请求适配器，将最终使用该适配器发送请求
		*/
		adapter: defaultAdapter,

		/**
		* 是否是正常的响应状态码，函数返回为 `false` 将直接报错
		* @param {number} status 响应状态码
		* @returns {boolean}
		*/
		validateStatus: function validateStatus(status) {
		return typeof status === 'number' && status >= 200 && status < 300
		},

		/********************************* 其他配置 ********************************/

		/**
		* 请求数据
		*/
		data: undefined,

		/**
		* 用户自定义中间件列表
		*/
		middleware: [],

		/**
		* 响应的返回内容项
		*
		* 合法值：
		* 1. `status`
		* 2. `statusText`
		* 3. `headers`
		* 4. `data`
		* 5. `config`
		* 6. `request`
		*
		* 支持别名，格式：
		* ```js
		* {
		* item: 'status,
		* alias: 'statusCode'
		* }
		* ```
		*/
		responseItems: ['status', 'statusText', 'headers', 'data'],
		}
		}

-60

lib/config/mergeConfig.js

		'use strict'

		const base = require('./defaults.js')

		/**
		* 合并配置项
		* @param {object} base 基础配置项，包含所有可配置键名
		* @param {object} defaults 实例的默认配置项
		* @param {object} comtom 本次请求设置的配置项
		*
		* 说明：
		* 1. 优先级：`comtom` > `defaults` > `base`
		*/
		module.exports = function mergeConfig(base, defaults, custom) {
		/**
		* 第一类键名
		*
		* 说明：
		* 1. 更高优先级存在值，则直接覆盖低优先级配置
		*/
		const firstTypeKeys = [
		'method',
		'baseURL',
		'url',
		'requestType',
		'responseType',
		'responseEncoding',
		'timeout',
		'retry',
		'mock',
		'adapter',
		'data',
		'middleware',
		'responseItems',
		'validateStatus',
		'sign',
		'debug',
		'logging',
		]

		/**
		* 第二类键名
		*
		* 说明：
		* 1. 更高优先级存在对应值，不会覆盖低优先级，而是做合并处理
		* 2. 对应值类型应为 `object`
		* 3. 对象内同名键，更高优先级覆盖低优先级
		*/
		const secondTypeKeys = ['headers', 'params']

		firstTypeKeys.forEach((key) => {
		custom[key] = custom[key] \|\| defaults[key] \|\| base[key]
		})

		secondTypeKeys.forEach((key) => {
		custom[key] = Object.assign({}, base[key], defaults[key] \|\| {}, custom[key] \|\| {})
		})

		return custom
		}

-300

lib/config/normalizeConfig.js

		'use strict'

		const methods = require('../static/methods.js')

		/**
		* 检验一个值是否是指定的类型，如果不是则报错
		* @param {*} value 要检验的数据
		* @param {*} type 类型
		* @param {*} name 名称
		*/
		function throwErrorIfWrongType(name, value, type) {
		if (typeof value !== type) {
		const message = `配置项 \`${name}\` 要求是一个 \`${type}\` 类型的值，但是你设置的 \`${name}\` = \`${value}\` 为 \`${typeof value}\` 类型`
		throw new Error(message)
		}
		}

		/**
		* 指定的值如果没有在列表中，则报错
		* @param {*} value 要检验的数据
		* @param {*} list 列表
		* @param {*} name 名称
		*/
		function throwErrorIfNotInclude(name, value, list) {
		if (!list.includes(value)) {
		const message =
		`配置项 \`${name}\` 仅支持以下值，你设置的 \`${name}\` = \`${value}\` 不在此范围内：\n` +
		list
		.map((value, index) => {
		return `${index + 1}. \`${value}\`\n`
		})
		.join('')
		throw new Error(message)
		}
		}

		/**
		* 整理参数（对原对象对校验和调整）
		* @param {object} config 配置项
		*
		* 说明：
		* 1. 将已知的参数做一个 `数据校验` 和规范化，未知数据原封不动保留
		*/
		module.exports = function normalizeConfig(config) {
		throwErrorIfWrongType('config', config, 'object')

		/**
		* 配置项 `method`
		*
		* 规则：
		* 1. 大写字符串
		* 2. 在指定范围内
		*/
		if (config.method !== undefined) {
		throwErrorIfWrongType('method', config.method, 'string')
		config.method = config.method.toUpperCase()
		throwErrorIfNotInclude('method', config.method, methods)
		}

		/**
		* 配置项 `baseURL`
		*
		* 规则：
		* 1. 字符串
		* 2. 以 `http://` 或 `https://` 开头
		*/
		if (config.baseURL !== undefined) {
		throwErrorIfWrongType('baseURL', config.baseURL, 'string')
		if (!config.baseURL.startsWith('http://') && !config.baseURL.startsWith('https://')) {
		throw new Error('配置项 `baseURL` 应该以 `http://` 或 `https://` 开头，例如 `https://www.jshttp.cn/`')
		}
		}

		/**
		* 配置项 `url`
		*
		* 规则：
		* 1. 字符串
		*/
		if (config.url !== undefined) {
		if (typeof config.url !== 'string') {
		throw new Error('配置项 `url` 应该是一个字符串类型，可以是绝对路径或相对路径，例如 `https://www.jshttp.cn/` 或 `/api`')
		}
		}

		/**
		* 配置项 `requestType`
		*
		* 规则：
		* 1. 字符串
		*
		* 合法值：
		* 1. `json` - 默认
		* 2. `text`
		* 3. `form`
		* 4. `arraybuffer`
		*/
		if (config.requestType !== undefined) {
		throwErrorIfWrongType('requestType', config.requestType, 'string')
		const validList = ['json', 'text', 'form', 'arraybuffer']
		throwErrorIfNotInclude('requestType', config.requestType, validList)
		}

		/**
		* 配置项 `responseType`
		*
		* 规则：
		* 1. 字符串
		*
		* 合法值：
		* 1. `json` - 全部适用
		* 2. `arraybuffer` - 全部适用
		* 3. `text` - 全部适用
		* 4. `blob` - 仅用于 `XMLHttpRequest`
		* 5. `document` - 仅用于 `XMLHttpRequest`
		* 6. `stream` - 仅用于 `Node.js`
		*/
		if (config.responseType !== undefined) {
		throwErrorIfWrongType('responseType', config.responseType, 'string')
		const validList = ['arraybuffer', 'blob', 'document', 'json', 'text', 'stream']
		throwErrorIfNotInclude('responseType', config.responseType, validList)
		}

		/**
		* 配置项 `responseEncoding`
		*
		* 规则：
		* 1. 字符串
		*
		* 合法值：
		* 1. `utf8` (或 `utf-8`)
		* 2. `base64`
		* 3. `hex`
		* 4. `ascii`
		* 5. `binary`
		* 6. `ucs2`
		* 7. `latin1`
		* 8. `utf16le`
		*/
		if (config.responseEncoding !== undefined) {
		throwErrorIfWrongType('responseEncoding', config.responseEncoding, 'string')
		const validList = ['utf8', 'utf-8', 'utf16le', 'latin1', 'base64', 'hex', 'ascii', 'binary', 'ucs2']
		throwErrorIfNotInclude('responseEncoding', config.responseEncoding, validList)
		}

		/**
		* 配置项 `timeout`
		*
		* 规则：
		* 1. 数字
		*/
		if (config.timeout !== undefined) {
		throwErrorIfWrongType('timeout', config.timeout, 'number')
		const timeout = parseInt(config.timeout, 10)
		config.timeout = timeout > 0 ? timeout : 0
		}

		/**
		* 配置项 `retry`
		*
		* 规则：
		* 1. 非负整数
		*/
		if (config.retry !== undefined) {
		if (!(Number.isInteger(config.retry) && config.retry >= 0)) {
		throw new Error('配置项 `retry` 要求是一个非负整数（0,1,2,...）')
		}
		}

		/**
		* 配置项 `headers`
		*
		* 规则：
		* 1. 对象
		*/
		if (config.headers !== undefined) {
		throwErrorIfWrongType('headers', config.headers, 'object')
		}

		/**
		* 配置项 `params`
		*
		* 规则：
		* 1. 对象
		*/
		if (config.params !== undefined) {
		throwErrorIfWrongType('params', config.params, 'object')
		}

		/**
		* 配置项 `mock`
		*
		* 规则：
		* 1. 对象
		*/
		if (config.mock !== undefined) {
		throwErrorIfWrongType('mock', config.mock, 'object')
		}

		/**
		* 配置项 `adapter`
		*
		* 规则：
		* 1. 函数
		*/
		if (config.adapter !== undefined) {
		throwErrorIfWrongType('adapter', config.adapter, 'function')
		}

		/**
		* 配置项 `validateStatus`
		*
		* 规则：
		* 1. 函数
		*/
		if (config.validateStatus !== undefined) {
		throwErrorIfWrongType('validateStatus', config.validateStatus, 'function')
		}

		/**
		* 配置项 `middleware`
		*
		* 规则：
		* 1. 数组
		* 2. 子项为函数或对象
		*/
		if (config.middleware !== undefined) {
		if (typeof config.middleware !== 'object' \|\| typeof config.middleware.length !== 'number') {
		throw new Error('配置项 `middleware` 要求是一个数组！')
		}

		config.middleware.forEach(function checkMiddlewareItemType(item) {
		if (typeof item !== 'function' && typeof item !== 'object') {
		throw new Error('配置项 `middleware` 的列表元素要求是一个函数或对象，请检查你的设置！')
		}
		})
		}

		/**
		* 配置项 `responseItems`
		*
		* 规则：
		* 1. 数组
		*/
		if (config.responseItems !== undefined) {
		if (typeof config.responseItems !== 'object' \|\| typeof config.responseItems.length !== 'number') {
		throw new Error('配置项 `responseItems` 要求是一个数组！')
		}

		if (config.responseItems.length === 0) {
		throw new Error('配置项 `responseItems` 应至少包含一个元素，可选值：`status`, `statusText`, `headers`, `data`, `config`, `request`')
		}

		const valid = ['status', 'statusText', 'headers', 'data', 'config', 'request']

		config.responseItems.forEach(function checkResponseItemInclude(item) {
		if (!valid.includes(item)) {
		throw new Error(
		'配置项 `responseItems` 的可选值：`status`, `statusText`, `headers`, `data`, `config`, `request`，你可以选择一项或多项，你选择的以下值不在可选值内：' +
		` \`${item}\` `
		)
		}
		})
		}

		/**
		* 配置项 `debug`
		*
		* 合法值：
		* 1. `true`
		* 2. `false`
		*/
		if (config.debug !== undefined) {
		if (config.debug !== true && config.debug !== false) {
		throw new Error('配置项 `debug` 的可选值：`true` 或 `false`')
		}
		}

		/**
		* 配置项 `logging`
		*
		* 规则：
		* 1. 是一个函数
		*/
		if (config.logging !== undefined) {
		throwErrorIfWrongType('logging', config.logging, 'function')
		}

		/**
		* 配置项 `data`
		*
		* 规则：
		* 1. 对 `data` 无校验
		*/
		if (config.data !== undefined) {
		// 空
		}

		return config
		}

-164

lib/core/applocation.js

		'use strict'

		const buildConfig = require('../config/buildConfig.js')
		const initialize = require('../lifetime/initialize.js')
		const dispatch = require('../lifetime/dispatch.js')
		const mergeConfig = require('../config/mergeConfig.js')
		const getDefaults = require('../config/defaults.js')
		const normalizeConfig = require('../config/normalizeConfig.js')
		const Context = require('./context.js')

		const getAliyunApigwSignatureMiddleware = require('../middleware/aliyunApigwSignature.js')

		const MIDDLEWARE = Symbol('application#middleware')
		const baseConfig = getDefaults()

		module.exports = class Application {
		constructor(defaultConfig) {
		this.defaults = normalizeConfig(defaultConfig)

		/**
		* 用户自定义中间件列表
		*
		* @param {function} [].fn 函数
		* @param {number} [].order 函数排序，用于在生成最终函数时，将列表重排（按数字升序排列）
		*/
		this[MIDDLEWARE] = this.defaults.middleware \|\| []
		}

		/**
		* 添加一个默认自定义中间件
		* @param {function\|object} obj 中间件
		*/
		use(obj) {
		this[MIDDLEWARE]['push'](obj)
		}

		/**
		* 根据配置，计算需要加入的签名中间件
		*/
		getSignMiddleware(config) {
		if (config.sign && typeof config.sign === 'object' && !config.sign.disable) {
		if (!(config.sign.key && config.sign.secret)) {
		throw new Error('签名中间件开启时，需要同时配置 `sign.key` 和 `sign.secret` 参数！')
		}
		if (!config.sign.type \|\| config.sign.type === 'aliyun') {
		return getAliyunApigwSignatureMiddleware(config.sign)
		}
		}
		}

		createPipeline(configMiddleware) {
		// 整理格式统一为 `{fn:function;order:number;}`
		const unifiedList = configMiddleware.map((value) => {
		if (typeof value === 'object') {
		const { fn, order } = value
		if (typeof fn === 'function' && typeof order === 'number') {
		return { fn, order }
		}
		} else if (typeof value === 'function') {
		return { fn: value, order: 100 }
		}
		throw new Error('中间件格式错误')
		})

		// 对中间件重新排序（按照 `order` 升序排列）
		unifiedList.sort((a, b) => {
		return a.order - b.order
		})

		// 获取中间件函数列表
		const middleware = unifiedList.map((value) => {
		return value.fn
		})

		middleware.push(dispatch)
		middleware.unshift(initialize)

		return function (context, next) {
		let index = -1
		function dispatch(i) {
		if (i <= index) return Promise.reject(new Error('next() 被执行了多次！'))
		index = i
		let fn = middleware[i]
		if (i === middleware.length) {
		fn = next
		}
		if (!fn) {
		return Promise.resolve()
		}
		try {
		return Promise.resolve(fn(context, dispatch.bind(null, i + 1)))
		} catch (err) {
		return Promise.reject(err)
		}
		}
		return dispatch(0)
		}
		}

		/**
		* 发起请求（包含重试逻辑）
		*/
		async request(...args) {
		// 整理参数，生成标准格式的 `config`
		const customConfig = buildConfig(...args)
		const config = mergeConfig(baseConfig, this.defaults, normalizeConfig(customConfig))

		// 加入 `签名中间件`
		const signFn = this.getSignMiddleware(config)
		if (signFn) {
		config.middleware.push({ fn: signFn, order: 9999 })
		}

		/** 最大重试次数 */
		let retry = config.retry

		/** 已重试次数 */
		let retries = -1

		/** 检验成功请求函数 */
		const validateStatus = config.validateStatus

		/** 响应结果列表 */
		const responses = []

		while (retry >= 0) {
		retry--
		retries++

		const result = await this.execSingleRequest(config, retries)
		responses.push(result)
		if (validateStatus(result.status)) {
		// 返回响应结果
		const { responseItems } = config
		const output = {}
		responseItems.forEach((key) => {
		if (typeof key === 'string') {
		output[key] = result[key]
		} else if (typeof key === 'object') {
		const { item, alias } = key
		output[alias] = result[item]
		} else {
		throw new Error('配置项 `responseItems` 格式错误')
		}
		})
		if (responseItems.includes('responses')) {
		output.responses = responses
		}
		return output
		}
		}
		throw new Error(responses[responses.length - 1])
		}

		/**
		* 执行单次请求
		*/
		async execSingleRequest(config, retries) {
		const context = new Context(config)
		context.retries = retries
		const fn = this.createPipeline(config.middleware)
		return await fn(context)
		}
		}

-150

lib/core/context.js

 'use strict'
 const getUrl = require('./getUrl.js')
 const mockAdapter = require('../adapters/mock.js')
 const STATE = Symbol('context#state')
 module.exports = class Context {
   constructor(config) {
     // 检查请求头
     this.checkHeadersUnique(config.headers)
     this.config = config
     this.adapter = config.mock && typeof config.mock === 'object' ? mockAdapter : config.adapter
     /** 公共存储空间 */
     this[STATE] = {}
   /**
    * 以指定名称存储当前时间
    * @param {string} name 名称
    */
   setTime(name) {
     /**
      * 辅助函数：对数字补零到指定位数
      * @param {number} number 被格式化的数字
      * @param {number} digit 格式化的位数
      * @returns {string}
      */
     function zerofill(number, digit = 2) {
       const zero = '0'
       for (let i = 0; i < digit; i++) {
         if (number < Math.pow(10, i + 1)) {
           const str = zero.repeat(digit - i - 1) + number.toString()
           return str
       return number
     const time = new Date()
     const year = time.getFullYear()
     const month = zerofill(time.getMonth())
     const day = zerofill(time.getDate())
     const hour = zerofill(time.getHours())
     const minute = zerofill(time.getMinutes())
     const second = zerofill(time.getSeconds())
     const millisecond = zerofill(time.getMilliseconds(), 3)
     const str = `${year}-${month}-${day} ${hour}:${minute}:${second}.${millisecond}`
     this[STATE][name] = time.getTime()
     this[STATE][name + 'Text'] = str
   get state() {
     return this[STATE]
   /**
    * 用于在中间件中快速获取 `url`
    */
   get url() {
     return getUrl(this.config.baseURL, this.config.url, this.config.params)
   /**
    * 检查请求头是否存在同名字段
    * @param {object} headers 请求头
    * 例如：`content-type` 和 `Content-Type` 为同名字段
    */
   checkHeadersUnique(headers) {
     const keys = Object.keys(headers)
     for (let i = 0; i < keys.length - 1; i++) {
       for (let j = i + 1; j < keys.length; j++) {
         if (keys[i].toUpperCase() === keys[j].toUpperCase()) {
           throw new Error(`请求头中的 \`${keys[i]}\` 和 \`${keys[j]}\` 同名冲突，请检查对应的请求头来源，最多只保留一个！`)
   getHeader(field) {
     if (typeof field !== 'string') {
       return ''
     Object.keys(this.config.headers).forEach((key) => {
       if (key.toUpperCase() === field.toUpperCase()) {
         return this.config.headers[key]
     })
   removeHeader(field) {
     if (typeof field !== 'string') {
       return ''
     Object.keys(this.config.headers).forEach((key) => {
       if (key.toUpperCase() === field.toUpperCase()) {
         delete this.config.headers[key]
     })
   setHeader(field, value) {
     this.removeHeader(field)
     this.config.headers[field] = value
   getParam(field) {
     return this.config.params[field]
   setParam(field, value) {
     this.config.params[field] = value
   /**
    * 合成打印日志所需的内容
    * @returns {object} content 日志内容对象
    * @returns {number} content.status 响应状态码
    * @returns {string} content.url 请求地址
    * @returns {object} content.config 配置项
    * @returns {number} content.startTime 发起请求任务时间（时间戳）
    * @returns {number} content.endTime 结束请求任务时间（时间戳）
    * @returns {number} content.requestTime 本次发起请求时间（时间戳）
    * @returns {number} content.responseTime 本次结束响应时间（时间戳）
    * @returns {string} content.startTimeText 发起请求任务时间（文本格式）
    * @returns {string} content.endTimeText 结束请求任务时间（文本格式）
    * @returns {string} content.requestTimeText 本次发起请求时间（文本格式）
    * @returns {string} content.responseTimeText 本次结束响应时间（文本格式）
    */
   getLoggingContent() {
     const ctx = this
     return {
       status: ctx.response.status,
       url: ctx.url,
       config: ctx.config,
       startTime: ctx.state.startTime,
       endTime: ctx.state.endTime,
       requestTime: ctx.state.requestTime,
       responseTime: ctx.state.responseTime,
       startTimeText: ctx.state.startTimeText,
       endTimeText: ctx.state.endTimeText,
       requestTimeText: ctx.state.requestTimeText,
       responseTimeText: ctx.state.responseTimeText,

-60

lib/core/getAdapter.js

		'use strict'

		/**
		* 根据环境变量，判断所处的环境类型，选择适配器
		*
		* 备注：
		* 1. `require` 语句不能在顶上提前使用，非特定环境引入模块将会无法运行而报错，只能在确定所处环境后引入
		*/
		module.exports = function getAdapter() {
		// 浏览器环境（各小程序环境把）
		/**
		* 普通浏览器环境、React Native 环境
		*
		* 说明：
		* 1. 各 `小程序` 环境把 `XMLHttpRequest` 直接禁用了，即
		* ```js
		* typeof XMLHttpRequest === 'undefined' // true
		* ```
		*/
		if (typeof XMLHttpRequest === 'function') {
		return require('../adapters/xhr.js')
		}

		/**
		* Node.js 环境
		*/
		if (typeof process === 'object' && typeof Buffer === 'function') {
		return require('../adapters/node.js')
		}

		/**
		* 微信小程序
		*/
		if (typeof wx === 'object' && typeof wx.request === 'function') {
		return require('../adapters/mini-wx.js')
		}

		/**
		* 支付宝小程序
		*/
		if (typeof my === 'object' && typeof my.request === 'function') {
		return require('../adapters/mini-my.js')
		}

		/**
		* QQ 小程序
		*/
		if (typeof qq === 'object' && typeof qq.request === 'function') {
		return require('../adapters/mini-qq.js')
		}

		/**
		* 字节跳动小程序
		*/
		if (typeof tt === 'object' && typeof tt.request === 'function') {
		return require('../adapters/mini-tt.js')
		}

		throw new Error('暂时无法识别当前的 Javascript 环境，请使用自定义适配器 `config.adapter` 或联系作者添加当前环境适配器！')
		}

-69

lib/core/response.js

		'use strict'

		const statuses = require('../static/statuses.js')

		const STATUS = Symbol('response#status')
		const STATUS_TEXT = Symbol('response#statusText')
		const HEADERS = Symbol('response#headers')
		const DATA = Symbol('response#data')

		module.exports = class Response {
		constructor(adapterRes) {
		this.config = adapterRes.config
		this.status = adapterRes.status
		this.statusText = adapterRes.statusText
		this.headers = adapterRes.headers
		this.data = adapterRes.data
		this.request = adapterRes.request
		}

		get status() {
		return this[STATUS]
		}

		set status(value) {
		const code = parseInt(value, 10)
		if (isNaN(code) \|\| code < 100 \|\| code > 599) {
		throw new Error('响应状态码的有效范围是 100 ~ 599，当前为 ' + value)
		}
		this[STATUS] = code
		}

		get statusText() {
		return this[STATUS_TEXT] \|\| statuses[this.status]
		}

		set statusText(value) {
		if (!value \|\| typeof value !== 'string') {
		return
		}
		this[STATUS_TEXT] = value
		}

		get headers() {
		return this[HEADERS] \|\| {}
		}

		set headers(value) {
		if (typeof value === 'object') {
		this[HEADERS] = value
		}
		}

		get data() {
		return this[DATA] \|\| null
		}

		set data(value) {
		if (typeof value === 'string' && this.config.responseType === 'json') {
		try {
		const json = JSON.parse(value)
		this[DATA] = json
		} catch (e) {
		this[DATA] = value
		}
		} else {
		this[DATA] = value
		}
		}
		}

-19

lib/lifetime/dispatch.js

		'use strict'

		const Response = require('../core/response.js')

		/**
		* 将请求适配器封装为中间件格式
		*/
		module.exports = async function dispatch(ctx) {
		// 记录发起请求时间
		ctx.setTime('requestTime')

		const result = await ctx.adapter(ctx.config)

		// 记录完成请求时间
		ctx.setTime('responseTime')

		ctx.response = new Response(result)
		ctx.request = result.request
		}

-31

lib/lifetime/initialize.js

		'use strict'

		/**
		* 初始化函数，用于放在第一个中间件
		*/
		module.exports = async function initialize(ctx, next) {
		// 记录本次请求任务开始时间
		ctx.setTime('startTime')

		await next()

		// 记录本次请求任务结束时间
		ctx.setTime('endTime')

		// 打印日志
		if (ctx.config.debug && typeof ctx.config.logging === 'function') {
		const content = ctx.getLoggingContent()
		ctx.config.logging(content)
		}

		return {
		status: ctx.response.status,
		statusText: ctx.response.statusText,
		headers: ctx.response.headers,
		data: ctx.response.data,
		request: ctx.response.request,

		url: ctx.url,
		config: ctx.config,
		}
		}

-120

lib/middleware/aliyunApigwSignature.js

		'use strict'

		const CryptoJS = require('../min/crypto-js.min.js')

		/**
		* 获取参与签名的请求头字段
		* @param {object} headers 请求头
		* @returns {string[]}
		*/
		function getSignHeaderKeys(headers) {
		/** 不参与 Header 签名的请求头 */
		const EXCLUDE_SIGN_HEADERS = ['x-ca-signature', 'x-xa-signature-headers', 'accept', 'content-md5', 'content-type', 'date']

		const signHeaderKeys = []
		Object.keys(headers).forEach((field) => {
		if (!EXCLUDE_SIGN_HEADERS.includes(field)) {
		signHeaderKeys.push(field)
		}
		})

		return signHeaderKeys.sort()
		}

		function getSignedHeadersString(signHeaderKeys, headers) {
		const list = []
		for (let i = 0; i < signHeaderKeys.length; i++) {
		const key = signHeaderKeys[i]
		const value = headers[key]
		list.push(key + ':' + (value ? value : ''))
		}
		return list.join('\n')
		}

		function getPathAndParams(url) {
		const urlRaw = url.replace('https://', '').replace('http://', '')
		return urlRaw.substr(urlRaw.indexOf('/'))
		}

		function md5(content) {
		return CryptoJS.MD5(content).toString(CryptoJS.enc.Base64)
		}

		function buildStringToSign(method, headers, signedHeadersString, pathAndParams) {
		const lf = '\n'
		const list = [method.toUpperCase(), lf]

		const arr = ['accept', 'content-md5', 'content-type', 'date']
		for (let i = 0; i < arr.length; i++) {
		const key = arr[i]
		if (headers[key]) {
		list.push(headers[key])
		}
		list.push(lf)
		}

		if (signedHeadersString) {
		list.push(signedHeadersString)
		list.push(lf)
		}

		if (pathAndParams) {
		list.push(pathAndParams)
		}

		return list.join('')
		}

		/**
		* 阿里云 API 网关签名加密
		* @see https://help.aliyun.com/document_detail/29475.html
		*/
		module.exports = function getAliyunApigwSignatureMiddleware(options) {
		const { key, secret, debug } = options

		const appKey = key
		const appSecret = secret

		return async function aliyunApigwSignature(ctx, next) {
		const originHeaders = ctx.config.headers
		const url = ctx.url

		// 处理请求头
		const headers = {}

		// 将请求头字段全部处理成 `小写`
		Object.keys(originHeaders).forEach((field) => {
		if (originHeaders[field]) {
		headers[field.toLowerCase()] = originHeaders[field]
		}
		})

		// 给请求头添加一些要求添加的字段
		headers['x-ca-key'] = appKey
		headers['x-ca-timestamp'] = Date.now()
		headers['accept'] = headers['accept'] \|\| '/'
		headers['content-type'] = headers['content-type'] \|\| 'application/json'

		// 该请求头要求为一个随机字符串，理论上使用 `UUID` 更好，为了少引入依赖，使用这种方法
		headers['x-ca-nonce'] = CryptoJS.MD5(Date.now().toString() + Math.random() * 10000).toString(CryptoJS.enc.Hex)

		if (ctx.config.method !== 'GET' && ctx.config.data) {
		headers['content-md5'] = md5(JSON.stringify(ctx.config.data))
		}

		const signHeaderKeys = getSignHeaderKeys(headers)
		headers['x-ca-signature-headers'] = signHeaderKeys.join(',')

		const pathAndParams = getPathAndParams(url)
		const signedHeadersString = getSignedHeadersString(signHeaderKeys, headers)
		const stringToSign = buildStringToSign(ctx.config.method, headers, signedHeadersString, pathAndParams)
		headers['x-ca-signature'] = CryptoJS.HmacSHA256(stringToSign, appSecret).toString(CryptoJS.enc.Base64)

		if (debug) {
		console.log(`当前签名字符串：\`${stringToSign.replace(/\n/g, '#')}\``)
		}

		ctx.config.headers = headers
		await next()
		}
		}

-1

lib/min/crypto-js.min.js

-50

lib/static/methods.js

		'use strict'

		/**
		* 所有 HTTP 请求方法合法值
		* From http.METHODS
		* @see https://nodejs.org/api/http.html#http_http_methods
		*/
		const ALL_METHODS = [
		'ACL',
		'BIND',
		'CHECKOUT',
		'CONNECT',
		'COPY',
		'DELETE',
		'GET',
		'HEAD',
		'LINK',
		'LOCK',
		'M-SEARCH',
		'MERGE',
		'MKACTIVITY',
		'MKCALENDAR',
		'MKCOL',
		'MOVE',
		'NOTIFY',
		'OPTIONS',
		'PATCH',
		'POST',
		'PROPFIND',
		'PROPPATCH',
		'PURGE',
		'PUT',
		'REBIND',
		'REPORT',
		'SEARCH',
		'SOURCE',
		'SUBSCRIBE',
		'TRACE',
		'UNBIND',
		'UNLINK',
		'UNLOCK',
		'UNSUBSCRIBE',
		]

		/**
		* 常用方法
		*/
		const COMMON_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE', 'HEAD', 'OPTIONS']

		module.exports = ALL_METHODS

jshttp - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes