@uni-use/request
Version:
An easy to use axios based http client combinatorial api with support for return sequentially
261 lines (258 loc) • 7.71 kB
JavaScript
import { __assign, __awaiter, __generator, __read } from 'tslib';
import axios from 'axios';
import wrapper from 'axios-series';
import until from 'use-until';
import { shallowRef, ref } from 'vue-demi';
import to from 'await-to-done';
var instance, axiosSeries;
var defaultOptions = {
unique: true,
orderly: true,
refetch: false,
immediate: true
};
// function useRequest<T = any>(
// config: InternalAxiosRequestConfig<T> & UseRequestConfig
// ): UseRequestReturn<T> & PromiseLike<UseRequestReturn<T>>
// function useRequest<T = any>(
// config: InternalAxiosRequestConfig<T>,
// options: UseRequestConfig
// ): UseRequestReturn<T> & PromiseLike<UseRequestReturn<T>>
function useRequest(url, config, options) {
config = Object.assign({}, defaultOptions, config);
var _a = options || config || {},
unique = _a.unique,
orderly = _a.orderly,
immediate = _a.immediate,
// setHeaders,
beforeRequest = _a.beforeRequest,
afterRequest = _a.afterRequest,
// updateDataOnError = false,
// onRequestError,
onResponseError = _a.onResponseError,
onError = _a.onError
// onCancel
;
// const { refetch } = config
// console.log(afterRequest)
var data = shallowRef(null);
var error = shallowRef(null);
var isFetching = ref(false);
var isFinished = ref(false);
var statusCode = ref(null);
var statusText = ref('');
var response = shallowRef();
// const execute = ref(null)
if (!instance) {
instance = axios.create({
timeout: 10000
});
// instance.interceptors.response.use(
// res => {
// response.value = res
// statusCode.value = res.status
// statusText.value = res.statusText
// return res
// },
// (err: any) => Promise.reject(err)
// )
}
// if (beforeRequest || onRequestError) {
// instance.interceptors.request.clear()
// instance.interceptors.request.use(
// config => {
// // isFetching.value = true
// // console.log(6000, isFetching.value, isFinished.value)
// return beforeRequest ? beforeRequest(config) : config
// // return config
// },
// (err: any) => {
// // error.value = err
// onRequestError && onRequestError(err)
// return Promise.reject(err)
// }
// )
// }
// if (onResponseError) {
// instance.interceptors.response.clear()
// instance.interceptors.response.use(
// res => {
// // response.value = res
// // statusCode.value = res.status
// // statusText.value = res.statusText
// // isFinished.value = true
// // isFetching.value = false
// // data.value = res.data
// // console.log(4000, isFetching.value, isFinished.value, Object.keys(res || {}))
// // return afterRequest ? afterRequest(res) : res
// return res
// },
// (err: any) => {
// // error.value = err
// onResponseError && onResponseError(err)
// return Promise.reject(err)
// }
// )
// }
if (!axiosSeries) axiosSeries = wrapper(instance, {
unique: unique,
orderly: orderly,
onCancel: function onCancel(err) {
console.info('onCancel => ', err.message, err.config);
}
});
// if (setHeaders) setHeaders(instance)
// if (
// // !instance.interceptors.request.handlers.some(
// // ({ fulfilled }) => fulfilled === beforeRequest
// // ) &&
// beforeRequest
// ) {
// instance.interceptors.request.use(beforeRequest, (err: any) => {
// onRequestError && onRequestError(err)
// return Promise.reject(err)
// })
// }
// if (
// // !instance.interceptors.response.handlers.some(
// // ({ fulfilled }) => fulfilled === afterRequest
// // ) &&
// afterRequest
// ) {
// instance.interceptors.response.use(afterRequest, (err: any) => {
// onResponseError && onResponseError(err)
// return Promise.reject(err)
// })
// }
// console.log(
// 7000,
// // options,
// // config,
// instance.interceptors.response.handlers
// // instance.interceptors.response.handlers.includes(afterRequest)
// )
/**
* request
*/
function request(config // InternalAxiosRequestConfig<T> & UseRequestConfig
// options?: UseRequestConfig
) {
return __awaiter(this, void 0, void 0, function () {
var _a, err, res, _b, _err_1;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
if (!beforeRequest) return [3 /*break*/, 2];
return [4 /*yield*/, beforeRequest(config)];
case 1:
config = _c.sent();
_c.label = 2;
case 2:
isFinished.value = false;
isFetching.value = true;
return [4 /*yield*/, to(axiosSeries(config))];
case 3:
_a = __read.apply(void 0, [_c.sent(), 2]), err = _a[0], res = _a[1];
if (!res) return [3 /*break*/, 10];
response.value = res;
statusCode.value = res.status;
statusText.value = res.statusText;
if (!afterRequest) return [3 /*break*/, 8];
_c.label = 4;
case 4:
_c.trys.push([4, 6,, 7]);
_b = data;
return [4 /*yield*/, afterRequest(res)];
case 5:
_b.value = _c.sent();
return [3 /*break*/, 7];
case 6:
_err_1 = _c.sent();
err = _err_1;
onResponseError && onResponseError(err);
return [3 /*break*/, 7];
case 7:
return [3 /*break*/, 9];
case 8:
data.value = res.data;
_c.label = 9;
case 9:
return [3 /*break*/, 11];
case 10:
if (err === null || err === void 0 ? void 0 : err.response) {
response.value = err.response;
statusCode.value = err.response.status;
statusText.value = err.response.statusText;
onResponseError && onResponseError(response.value);
} else {
onError && onError(err);
}
_c.label = 11;
case 11:
error.value = err;
isFinished.value = true;
isFetching.value = false;
return [2 /*return*/, data.value];
}
});
});
}
/**
* create request
*/
// function createRequest() {
// return ''
// }
var shell = {
isFinished: isFinished,
statusCode: statusCode,
statusText: statusText,
response: response,
error: error,
data: data,
isFetching: isFetching,
// canAbort,
// aborted,
// abort,
// execute,
// json: setType('json'),
//
request: request
// createRequest,
// onResponse: responseEvent.on,
// onError: errorEvent.on,
// onFinally: finallyEvent.on
};
// function setType(type: DataType) {
// return () => {
// if (!isFetching.value) {
// config.type = type
// return {
// ...shell,
// then(onFulfilled: any, onRejected: any) {
// return waitUntilFinished().then(onFulfilled, onRejected)
// }
// } as any
// }
// return undefined
// }
// }
function waitUntilFinished() {
return new Promise(function (resolve, reject) {
until(isFinished).toBe(true).then(function () {
return resolve(shell);
}).catch(function (error) {
return reject(error);
});
});
}
if (immediate) Promise.resolve().then(function () {
return request(config);
});
return __assign(__assign({}, shell), {
then: function then(onFulfilled, onRejected) {
return waitUntilFinished().then(onFulfilled, onRejected);
}
});
}
export { useRequest as default };