@varlet/axle 0.0.24 → 0.0.25

package/es/use.d.ts

@@ -4,24 +4,33 @@ export interface RunOptions<P> {
     url?: string;
     params?: P;
     config?: AxleRequestConfig;
+    _retryCount?: number;
+}
+export type Run<R, P> = (options?: RunOptions<P>) => Promise<R>;
+export interface UseAxleRefs<D> {
+    data: Ref<D>;
+    loading: Ref<boolean>;
+    error: Ref<Error | undefined>;
+    uploadProgress: Ref<number>;
+    downloadProgress: Ref<number>;
 }
-export type Run<D, P> = (options?: RunOptions<P>) => Promise<D>;
 export interface UseAxleOptions<D = any, R = any, P = Record<string, any>> {
     url: string;
     runner: ReturnType<typeof createFetchHelper> | ReturnType<typeof createModifyHelper>;
     data: D;
     params?: P;
+    retry?: number;
     config?: AxleRequestConfig;
     immediate?: boolean;
-    onBefore?(): void;
-    onAfter?(): void;
-    onTransform?(response: R, prev: D): D;
-    onSuccess?(response: R): void;
-    onError?(error: Error): void;
+    onBefore?(refs: UseAxleRefs<D>): void;
+    onAfter?(refs: UseAxleRefs<D>): void;
+    onTransform?(response: R, refs: UseAxleRefs<D>): D;
+    onSuccess?(response: R, refs: UseAxleRefs<D>): void;
+    onError?(error: Error, refs: UseAxleRefs<D>): void;
 }
-export type UseAxleReturn<D, P> = [
+export type UseAxleInstance<D, R, P> = [
     data: Ref<D>,
-    run: Run<D, P>,
+    run: Run<R, P>,
     extra: {
         uploadProgress: Ref<number>;
         downloadProgress: Ref<number>;
@@ -31,6 +40,6 @@ export type UseAxleReturn<D, P> = [
     }
 ];
 export interface CreateUseAxleOptions {
-    onTransform?(response: any, prev: any): any;
+    onTransform?(response: any, refs: any): any;
 }
-export declare function createUseAxle(options?: CreateUseAxleOptions): <D = any, R = any, P = Record<string, any>>(options: UseAxleOptions<D, R, P>) => UseAxleReturn<D, P>;
+export declare function createUseAxle(options?: CreateUseAxleOptions): <D = any, R = any, P = Record<string, any>>(options: UseAxleOptions<D, R, P>) => UseAxleInstance<D, R, P>;

package/es/use.js

@@ -3,18 +3,23 @@ export function createUseAxle(options = {}) {
     const { onTransform: defaultOnTransform } = options;
     const useAxle = (options) => {
         var _a;
-        const { url, runner, immediate, data: initialData, params: initialParams, config: initialConfig, onBefore = () => { }, onAfter = () => { }, onTransform = (_a = defaultOnTransform) !== null && _a !== void 0 ? _a : ((response) => response), onSuccess = () => { }, onError = () => { }, } = options;
+        const { url, runner, immediate, data: initialData, params: initialParams, config: initialConfig, retry = 0, onBefore = () => { }, onAfter = () => { }, onTransform = (_a = defaultOnTransform) !== null && _a !== void 0 ? _a : ((response) => response), onSuccess = () => { }, onError = () => { }, } = options;
         const initialUrl = url;
         const data = ref(initialData);
         const loading = ref(false);
         const error = ref();
         const downloadProgress = ref(0);
         const uploadProgress = ref(0);
-        let controller = new AbortController();
-        const abort = () => {
-            controller.abort();
+        const shouldRetry = retry > 0;
+        const refs = {
+            data,
+            loading,
+            error,
+            downloadProgress,
+            uploadProgress
         };
-        const run = (options = {}) => {
+        let controller = new AbortController();
+        const run = async (options = {}) => {
             var _a;
             if (controller.signal.aborted) {
                 controller = new AbortController();
@@ -22,31 +27,38 @@ export function createUseAxle(options = {}) {
             uploadProgress.value = 0;
             downloadProgress.value = 0;
             const url = (_a = options.url) !== null && _a !== void 0 ? _a : initialUrl;
-            onBefore();
+            onBefore(refs);
             loading.value = true;
-            return runner(url, options.params, Object.assign({ signal: controller.signal, onUploadProgress(event) {
-                    var _a;
-                    uploadProgress.value = (_a = event.progress) !== null && _a !== void 0 ? _a : 0;
-                },
-                onDownloadProgress(event) {
-                    var _a;
-                    downloadProgress.value = (_a = event.progress) !== null && _a !== void 0 ? _a : 0;
-                } }, options.config))
-                .then((response) => {
-                data.value = onTransform(response, data.value);
+            try {
+                const response = await runner(url, options.params, Object.assign({ signal: controller.signal, onUploadProgress(event) {
+                        var _a;
+                        uploadProgress.value = (_a = event.progress) !== null && _a !== void 0 ? _a : 0;
+                    },
+                    onDownloadProgress(event) {
+                        var _a;
+                        downloadProgress.value = (_a = event.progress) !== null && _a !== void 0 ? _a : 0;
+                    } }, options.config));
+                data.value = onTransform(response, refs);
                 error.value = undefined;
-                onSuccess(response);
-                return data.value;
-            })
-                .catch((responseError) => {
+                onSuccess(response, refs);
+                loading.value = false;
+                onAfter(refs);
+                return response;
+            }
+            catch (responseError) {
+                const currentRetryCount = options._retryCount == null ? 0 : options._retryCount;
+                if (shouldRetry && currentRetryCount < retry) {
+                    return run(Object.assign(Object.assign({}, options), { _retryCount: currentRetryCount + 1 }));
+                }
                 error.value = responseError;
-                onError(responseError);
-                throw responseError;
-            })
-                .finally(() => {
+                onError(responseError, refs);
                 loading.value = false;
-                onAfter();
-            });
+                onAfter(refs);
+                throw responseError;
+            }
+        };
+        const abort = () => {
+            controller.abort();
         };
         if (immediate) {
             run({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/axle",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "description": "A useful axios helper",
   "type": "module",
   "main": "es/index.js",