@varlet/axle 0.0.23 → 0.0.25

package/es/use.d.ts

@@ -1,33 +1,45 @@
-import { type Ref, type UnwrapRef } from 'vue';
+import { type Ref } from 'vue';
 import { type AxleRequestConfig, createFetchHelper, createModifyHelper } from './instance.js';
 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<UnwrapRef<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: UnwrapRef<R>, prev: UnwrapRef<D>): UnwrapRef<D>;
-    onSuccess?(response: UnwrapRef<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> = [
-    data: Ref<UnwrapRef<D>>,
-    run: Run<D, P>,
+export type UseAxleInstance<D, R, P> = [
+    data: Ref<D>,
+    run: Run<R, P>,
     extra: {
-        loading: Ref<UnwrapRef<boolean>>;
-        error: Ref<UnwrapRef<Error | undefined>>;
+        uploadProgress: Ref<number>;
+        downloadProgress: Ref<number>;
+        loading: Ref<boolean>;
+        error: Ref<Error | undefined>;
+        abort(): void;
     }
 ];
 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,32 +3,62 @@ 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 run = (options = {}) => {
+        const downloadProgress = ref(0);
+        const uploadProgress = ref(0);
+        const shouldRetry = retry > 0;
+        const refs = {
+            data,
+            loading,
+            error,
+            downloadProgress,
+            uploadProgress
+        };
+        let controller = new AbortController();
+        const run = async (options = {}) => {
             var _a;
+            if (controller.signal.aborted) {
+                controller = new AbortController();
+            }
+            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, 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({
@@ -43,6 +73,9 @@ export function createUseAxle(options = {}) {
             {
                 loading,
                 error,
+                uploadProgress,
+                downloadProgress,
+                abort,
             },
         ];
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/axle",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "A useful axios helper",
   "type": "module",
   "main": "es/index.js",
@@ -38,7 +38,7 @@
     "@varlet/cli": "^2.11.8",
     "rimraf": "^5.0.1",
     "typescript": "^5.1.5",
-    "vue": "^3.3.4"
+    "vue": "3.3.4"
   },
   "repository": {
     "type": "git",