@varlet/axle 0.11.2 → 0.13.0

package/lib/use.cjs

@@ -34,6 +34,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/use.ts
 var use_exports = {};
 __export(use_exports, {
+  cleanupCacheBuffer: () => cleanupCacheBuffer,
   createUseAxle: () => createUseAxle,
   normalizeValueGetter: () => normalizeValueGetter,
   useAverageProgress: () => useAverageProgress,
@@ -44,17 +45,19 @@ module.exports = __toCommonJS(use_exports);
 var import_vue4 = require("vue");
 var import_rattail = require("rattail");
 
-// src/composables/useValues.ts
+// src/composables/useAverageProgress.ts
 var import_vue = require("vue");
-function useValues(...valueCollection) {
-  return (0, import_vue.computed)({
-    get: () => valueCollection.map((value) => value.value),
-    set(values) {
-      valueCollection.forEach((value, index) => {
-        value.value = values[index];
-      });
-    }
-  });
+function useAverageProgress(...progressCollection) {
+  const averageProgress = (0, import_vue.ref)(0);
+  (0, import_vue.watch)(
+    () => progressCollection.map((progress) => progress.value),
+    (newProgressCollection) => {
+      const total = newProgressCollection.reduce((total2, progress) => total2 + progress, 0);
+      averageProgress.value = total / progressCollection.length;
+    },
+    { immediate: true }
+  );
+  return averageProgress;
 }
 
 // src/composables/useHasLoading.ts
@@ -71,31 +74,38 @@ function useHasLoading(...loadings) {
   return hasLoading;
 }
 
-// src/composables/useAverageProgress.ts
+// src/composables/useValues.ts
 var import_vue3 = require("vue");
-function useAverageProgress(...progressCollection) {
-  const averageProgress = (0, import_vue3.ref)(0);
-  (0, import_vue3.watch)(
-    () => progressCollection.map((progress) => progress.value),
-    (newProgressCollection) => {
-      const total = newProgressCollection.reduce((total2, progress) => total2 + progress, 0);
-      averageProgress.value = total / progressCollection.length;
-    },
-    { immediate: true }
-  );
-  return averageProgress;
+function useValues(...valueCollection) {
+  return (0, import_vue3.computed)({
+    get: () => valueCollection.map((value) => value.value),
+    set(values) {
+      valueCollection.forEach((value, index) => {
+        value.value = values[index];
+      });
+    }
+  });
 }
 
 // src/use.ts
 function normalizeValueGetter(valueGetter) {
   return (0, import_rattail.isFunction)(valueGetter) ? valueGetter() : valueGetter;
 }
+var cacheBuffer = /* @__PURE__ */ new Map();
+function cleanupCacheBuffer() {
+  cacheBuffer.forEach((value, key) => {
+    if (value.expiredTime && Date.now() >= value.expiredTime) {
+      cacheBuffer.delete(key);
+    }
+  });
+}
 function createUseAxle(options) {
   const {
     axle,
     onTransform: defaultOnTransform,
     immediate: defaultImmediate = true,
-    abortOnUnmount: defaultAbortOnUnmount = true
+    abortOnUnmount: defaultAbortOnUnmount = true,
+    cacheTime: defaultCacheTime = Infinity
   } = options;
   const useAxle = (options2) => {
     const {
@@ -103,11 +113,19 @@ function createUseAxle(options) {
       method,
       immediate = defaultImmediate,
       abortOnUnmount = defaultAbortOnUnmount,
+      cacheTime = defaultCacheTime,
+      cacheKey,
+      pollingInterval,
+      pollingOnHidden = true,
+      pollingOnDeactivated = false,
+      refreshOnWindowFocus = false,
       value: initialValue,
       resetValue: initialResetValue,
       cloneResetValue: initialCloneResetValue,
       params: initialParamsOrGetter,
       config: initialConfigOrGetter,
+      watch: watchOptions,
+      runnable = () => true,
       onBefore = () => {
       },
       onAfter = () => {
@@ -123,86 +141,182 @@ function createUseAxle(options) {
     const error = (0, import_vue4.ref)();
     const downloadProgress = (0, import_vue4.ref)(0);
     const uploadProgress = (0, import_vue4.ref)(0);
+    const pollingCanceled = (0, import_vue4.ref)(false);
     const refs = {
       value,
       loading,
       error,
       downloadProgress,
-      uploadProgress
+      uploadProgress,
+      pollingCanceled
     };
     const extra = {
       uploadProgress,
       downloadProgress,
       loading,
       error,
+      pollingCanceled,
       abort,
-      resetValue
+      resetValue,
+      invalidateCache,
+      cancelPolling
     };
     let controller = new AbortController();
-    const run = Object.assign(
-      async (options3 = {}) => {
-        var _a, _b, _c, _d, _e;
-        if (controller.signal.aborted) {
-          controller = new AbortController();
+    let pollingTimer = null;
+    let deactivated = false;
+    let hidden = false;
+    const run = Object.assign(async (options3 = {}) => {
+      var _a, _b, _c, _d, _e;
+      if (!runnable()) {
+        return;
+      }
+      pollingCanceled.value = false;
+      if (controller.signal.aborted) {
+        controller = new AbortController();
+      }
+      const resetValueOption = (_b = (_a = options3.resetValue) != null ? _a : initialResetValue) != null ? _b : false;
+      if (resetValueOption === true) {
+        resetValue(options3);
+      }
+      uploadProgress.value = 0;
+      downloadProgress.value = 0;
+      const url = (_c = options3.url) != null ? _c : normalizeValueGetter(initialUrlOrGetter);
+      const params = (_d = options3.params) != null ? _d : normalizeValueGetter(initialParamsOrGetter);
+      const config = (_e = options3.config) != null ? _e : normalizeValueGetter(initialConfigOrGetter);
+      const normalizedCacheKey = cacheKey ? normalizeValueGetter(cacheKey) : void 0;
+      onBefore(refs);
+      loading.value = true;
+      try {
+        cleanupCacheBuffer();
+        const response = await getResponse();
+        if (shouldSetCacheResponse(normalizedCacheKey)) {
+          const cache = cacheBuffer.get(normalizedCacheKey);
+          cache.response = response;
+          cache.expiredTime = Date.now() + cacheTime;
         }
-        const resetValueOption = (_b = (_a = options3.resetValue) != null ? _a : initialResetValue) != null ? _b : false;
-        if (resetValueOption === true) {
-          resetValue(options3);
+        value.value = await onTransform(response, refs);
+        error.value = void 0;
+        onSuccess(response, refs);
+        loading.value = false;
+        onAfter(refs);
+        return response;
+      } catch (responseError) {
+        error.value = responseError;
+        onError(responseError, refs);
+        loading.value = false;
+        onAfter(refs);
+        throw responseError;
+      } finally {
+        clearPolling();
+        startPolling();
+      }
+      function getResponse() {
+        if (shouldUseCache(normalizedCacheKey)) {
+          return JSON.parse(JSON.stringify(cacheBuffer.get(normalizedCacheKey).response));
         }
-        uploadProgress.value = 0;
-        downloadProgress.value = 0;
-        const url = (_c = options3.url) != null ? _c : normalizeValueGetter(initialUrlOrGetter);
-        const params = (_d = options3.params) != null ? _d : normalizeValueGetter(initialParamsOrGetter);
-        const config = (_e = options3.config) != null ? _e : normalizeValueGetter(initialConfigOrGetter);
-        onBefore(refs);
-        loading.value = true;
-        try {
-          const response = await axle[method](url, params, __spreadValues({
-            signal: controller.signal,
-            onUploadProgress(event) {
-              var _a2;
-              uploadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
-            },
-            onDownloadProgress(event) {
-              var _a2;
-              downloadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
-            }
-          }, config));
-          value.value = await onTransform(response, refs);
-          error.value = void 0;
-          onSuccess(response, refs);
-          loading.value = false;
-          onAfter(refs);
-          return response;
-        } catch (responseError) {
-          error.value = responseError;
-          onError(responseError, refs);
-          loading.value = false;
-          onAfter(refs);
-          throw responseError;
+        if (shouldAwaitCachePromise(normalizedCacheKey)) {
+          return cacheBuffer.get(normalizedCacheKey).promise;
         }
-      },
-      {
-        uploadProgress,
-        downloadProgress,
-        loading,
-        error,
-        abort,
-        resetValue
-      }
-    );
+        const promise = fetchResponse();
+        if (shouldSetCachePromise(normalizedCacheKey)) {
+          cacheBuffer.set(normalizedCacheKey, { promise });
+        }
+        return promise;
+      }
+      function fetchResponse() {
+        return axle[method](url, params, __spreadValues({
+          signal: controller.signal,
+          onUploadProgress(event) {
+            var _a2;
+            uploadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
+          },
+          onDownloadProgress(event) {
+            var _a2;
+            downloadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
+          }
+        }, config));
+      }
+      function shouldUseCache(key) {
+        if (!key || !cacheBuffer.has(key)) {
+          return false;
+        }
+        const buffer = cacheBuffer.get(key);
+        return buffer.response != null;
+      }
+      function shouldAwaitCachePromise(key) {
+        if (!key || !cacheBuffer.has(key)) {
+          return false;
+        }
+        const buffer = cacheBuffer.get(key);
+        return buffer.promise;
+      }
+      function shouldSetCachePromise(key) {
+        if (!key || cacheBuffer.has(key)) {
+          return false;
+        }
+        return true;
+      }
+      function shouldSetCacheResponse(key) {
+        if (!key || !cacheBuffer.has(key)) {
+          return false;
+        }
+        const buffer = cacheBuffer.get(key);
+        return buffer.response == null;
+      }
+    }, extra);
     if (immediate) {
-      run({
+      runWithInitialConfig();
+    }
+    if ((0, import_vue4.getCurrentInstance)()) {
+      (0, import_vue4.onActivated)(() => {
+        deactivated = false;
+        addVisibilityChangeListener();
+        addWindowFocusListener();
+        startPolling();
+      });
+      (0, import_vue4.onMounted)(() => {
+        addVisibilityChangeListener();
+        addWindowFocusListener();
+      });
+      (0, import_vue4.onDeactivated)(() => {
+        deactivated = true;
+        removeVisibilityChangeListener();
+        removeWindowFocusListener();
+        clearPolling();
+      });
+      (0, import_vue4.onUnmounted)(() => {
+        removeVisibilityChangeListener();
+        removeWindowFocusListener();
+        cancelPolling();
+      });
+      if (abortOnUnmount) {
+        (0, import_vue4.onUnmounted)(() => {
+          abort();
+        });
+      }
+      if (watchOptions) {
+        const normalizedWatchOptions = watchOptions === true ? { params: true, config: true } : __spreadValues({ params: false, config: false }, watchOptions);
+        const enableWatchParams = (0, import_rattail.isFunction)(initialParamsOrGetter) && normalizedWatchOptions.params;
+        const enableWatchConfig = (0, import_rattail.isFunction)(initialConfigOrGetter) && normalizedWatchOptions.config;
+        (0, import_vue4.watch)(
+          () => [
+            enableWatchParams ? normalizeValueGetter(initialParamsOrGetter) : void 0,
+            enableWatchConfig ? normalizeValueGetter(initialConfigOrGetter) : void 0,
+            normalizedWatchOptions._custom ? normalizedWatchOptions._custom() : void 0
+          ],
+          () => {
+            runWithInitialConfig();
+          }
+        );
+      }
+    }
+    function runWithInitialConfig() {
+      return run({
         url: normalizeValueGetter(initialUrlOrGetter),
         params: normalizeValueGetter(initialParamsOrGetter),
         config: normalizeValueGetter(initialConfigOrGetter)
       });
     }
-    if (abortOnUnmount && (0, import_vue4.getCurrentInstance)()) {
-      (0, import_vue4.onUnmounted)(() => {
-        abort();
-      });
-    }
     function resetValue(options3 = {}) {
       var _a, _b;
       const cloneResetValue = (_b = (_a = options3.cloneResetValue) != null ? _a : initialCloneResetValue) != null ? _b : false;
@@ -212,12 +326,71 @@ function createUseAxle(options) {
     function abort() {
       controller.abort();
     }
+    function addWindowFocusListener() {
+      if (typeof window !== "undefined") {
+        window.addEventListener("focus", handleWindowFocus);
+      }
+    }
+    function removeWindowFocusListener() {
+      if (typeof window !== "undefined") {
+        window.removeEventListener("focus", handleWindowFocus);
+      }
+    }
+    function handleWindowFocus() {
+      if (refreshOnWindowFocus) {
+        runWithInitialConfig();
+      }
+    }
+    function addVisibilityChangeListener() {
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", handleVisibilityChange);
+      }
+    }
+    function removeVisibilityChangeListener() {
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+      }
+    }
+    function handleVisibilityChange() {
+      hidden = document.visibilityState === "hidden";
+      if (pollingOnHidden) {
+        return;
+      }
+      hidden ? clearPolling() : startPolling();
+    }
+    function startPolling() {
+      if (pollingInterval == null || pollingCanceled.value || pollingTimer != null || deactivated && !pollingOnDeactivated || hidden && !pollingOnHidden) {
+        return;
+      }
+      pollingTimer = setTimeout(() => {
+        runWithInitialConfig();
+      }, pollingInterval);
+    }
+    function clearPolling() {
+      if (pollingTimer == null) {
+        return;
+      }
+      clearTimeout(pollingTimer);
+      pollingTimer = null;
+    }
+    function cancelPolling() {
+      clearPolling();
+      pollingCanceled.value = true;
+    }
+    function invalidateCache() {
+      const normalizedCacheKey = cacheKey ? normalizeValueGetter(cacheKey) : void 0;
+      if (!normalizedCacheKey || !cacheBuffer.has(normalizedCacheKey)) {
+        return;
+      }
+      cacheBuffer.delete(normalizedCacheKey);
+    }
     return [value, run, extra];
   };
   return useAxle;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  cleanupCacheBuffer,
   createUseAxle,
   normalizeValueGetter,
   useAverageProgress,

package/lib/use.d.cts

@@ -2,12 +2,13 @@ import { Ref, WritableComputedRef } from 'vue';
 import { A as AxleRequestConfig, d as RunnerMethod, e as AxleInstance } from './instance-857fe07c.js';
 import 'axios';
 
-declare function useValues<T extends Ref<any>[]>(...valueCollection: T): WritableComputedRef<T[number]['value'][]>;
+declare function useAverageProgress(...progressCollection: Ref<number>[]): Ref<number>;
 
 declare function useHasLoading(...loadings: Ref<boolean>[]): Ref<boolean>;
 
-declare function useAverageProgress(...progressCollection: Ref<number>[]): Ref<number>;
+declare function useValues<T extends Ref<any>[]>(...valueCollection: T): WritableComputedRef<T[number]['value'][]>;
 
+type Runnable = () => boolean;
 interface RunOptions<V, P, D> {
     url?: string;
     params?: P;
@@ -16,12 +17,15 @@ interface RunOptions<V, P, D> {
     cloneResetValue?: boolean | ((value: V) => V);
 }
 type UseAxleExtra<V> = {
-    uploadProgress: Ref<number>;
-    downloadProgress: Ref<number>;
     loading: Ref<boolean>;
     error: Ref<Error | undefined>;
+    uploadProgress: Ref<number>;
+    downloadProgress: Ref<number>;
+    pollingCanceled: Ref<boolean>;
     abort(): void;
     resetValue(options?: ResetValueOptions<V>): void;
+    invalidateCache(): void;
+    cancelPolling(): void;
 };
 interface UseAxleRefs<V> {
     value: Ref<V>;
@@ -29,10 +33,16 @@ interface UseAxleRefs<V> {
     error: Ref<Error | undefined>;
     uploadProgress: Ref<number>;
     downloadProgress: Ref<number>;
+    pollingCanceled: Ref<boolean>;
 }
 type Run<V, R, P, D> = {
     (options?: RunOptions<V, P, D>): Promise<R>;
 } & UseAxleExtra<V>;
+type WatchOptions = boolean | {
+    params?: boolean;
+    config?: boolean;
+    _custom?: () => any;
+};
 interface UseAxleOptions<V = any, R = any, P = Record<string, any>, D = Record<string, any>> {
     url: string | (() => string);
     method: RunnerMethod;
@@ -41,7 +51,14 @@ interface UseAxleOptions<V = any, R = any, P = Record<string, any>, D = Record<s
     resetValue?: boolean;
     cloneResetValue?: boolean | ((value: V) => V);
     abortOnUnmount?: boolean;
+    cacheKey?: string | (() => string);
+    cacheTime?: number;
     config?: AxleRequestConfig<D> | (() => AxleRequestConfig<D>);
+    watch?: WatchOptions;
+    pollingInterval?: number;
+    pollingOnHidden?: boolean;
+    pollingOnDeactivated?: boolean;
+    refreshOnWindowFocus?: boolean;
     params?: P | (() => P);
     onBefore?(refs: UseAxleRefs<V>): void;
     onAfter?(refs: UseAxleRefs<V>): void;
@@ -57,10 +74,18 @@ interface CreateUseAxleOptions {
     axle: AxleInstance;
     immediate?: boolean;
     abortOnUnmount?: boolean;
+    cacheTime?: number;
     onTransform?(response: any, refs: any): any;
 }
-type UseAxle = <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptions<V, R, P, D>) => UseAxleInstance<V, R, P, D>;
+type UseAxleOptionsWithRunnable<V = any, R = any, P = Record<string, any>, D = Record<string, any>> = UseAxleOptions<V, R, P, D> & {
+    runnable: Runnable;
+};
+interface UseAxle {
+    <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptionsWithRunnable<V, R, P, D>): UseAxleInstance<V, R | undefined, P, D>;
+    <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptions<V, R, P, D>): UseAxleInstance<V, R, P, D>;
+}
 declare function normalizeValueGetter<T>(valueGetter: T | (() => T)): T;
+declare function cleanupCacheBuffer(): void;
 declare function createUseAxle(options: CreateUseAxleOptions): UseAxle;
 
-export { CreateUseAxleOptions, ResetValueOptions, Run, RunOptions, UseAxle, UseAxleExtra, UseAxleInstance, UseAxleOptions, UseAxleRefs, createUseAxle, normalizeValueGetter, useAverageProgress, useHasLoading, useValues };
+export { CreateUseAxleOptions, ResetValueOptions, Run, RunOptions, Runnable, UseAxle, UseAxleExtra, UseAxleInstance, UseAxleOptions, UseAxleOptionsWithRunnable, UseAxleRefs, WatchOptions, cleanupCacheBuffer, createUseAxle, normalizeValueGetter, useAverageProgress, useHasLoading, useValues };

package/lib/use.d.ts

@@ -2,12 +2,13 @@ import { Ref, WritableComputedRef } from 'vue';
 import { A as AxleRequestConfig, d as RunnerMethod, e as AxleInstance } from './instance-857fe07c.js';
 import 'axios';
 
-declare function useValues<T extends Ref<any>[]>(...valueCollection: T): WritableComputedRef<T[number]['value'][]>;
+declare function useAverageProgress(...progressCollection: Ref<number>[]): Ref<number>;
 
 declare function useHasLoading(...loadings: Ref<boolean>[]): Ref<boolean>;
 
-declare function useAverageProgress(...progressCollection: Ref<number>[]): Ref<number>;
+declare function useValues<T extends Ref<any>[]>(...valueCollection: T): WritableComputedRef<T[number]['value'][]>;
 
+type Runnable = () => boolean;
 interface RunOptions<V, P, D> {
     url?: string;
     params?: P;
@@ -16,12 +17,15 @@ interface RunOptions<V, P, D> {
     cloneResetValue?: boolean | ((value: V) => V);
 }
 type UseAxleExtra<V> = {
-    uploadProgress: Ref<number>;
-    downloadProgress: Ref<number>;
     loading: Ref<boolean>;
     error: Ref<Error | undefined>;
+    uploadProgress: Ref<number>;
+    downloadProgress: Ref<number>;
+    pollingCanceled: Ref<boolean>;
     abort(): void;
     resetValue(options?: ResetValueOptions<V>): void;
+    invalidateCache(): void;
+    cancelPolling(): void;
 };
 interface UseAxleRefs<V> {
     value: Ref<V>;
@@ -29,10 +33,16 @@ interface UseAxleRefs<V> {
     error: Ref<Error | undefined>;
     uploadProgress: Ref<number>;
     downloadProgress: Ref<number>;
+    pollingCanceled: Ref<boolean>;
 }
 type Run<V, R, P, D> = {
     (options?: RunOptions<V, P, D>): Promise<R>;
 } & UseAxleExtra<V>;
+type WatchOptions = boolean | {
+    params?: boolean;
+    config?: boolean;
+    _custom?: () => any;
+};
 interface UseAxleOptions<V = any, R = any, P = Record<string, any>, D = Record<string, any>> {
     url: string | (() => string);
     method: RunnerMethod;
@@ -41,7 +51,14 @@ interface UseAxleOptions<V = any, R = any, P = Record<string, any>, D = Record<s
     resetValue?: boolean;
     cloneResetValue?: boolean | ((value: V) => V);
     abortOnUnmount?: boolean;
+    cacheKey?: string | (() => string);
+    cacheTime?: number;
     config?: AxleRequestConfig<D> | (() => AxleRequestConfig<D>);
+    watch?: WatchOptions;
+    pollingInterval?: number;
+    pollingOnHidden?: boolean;
+    pollingOnDeactivated?: boolean;
+    refreshOnWindowFocus?: boolean;
     params?: P | (() => P);
     onBefore?(refs: UseAxleRefs<V>): void;
     onAfter?(refs: UseAxleRefs<V>): void;
@@ -57,10 +74,18 @@ interface CreateUseAxleOptions {
     axle: AxleInstance;
     immediate?: boolean;
     abortOnUnmount?: boolean;
+    cacheTime?: number;
     onTransform?(response: any, refs: any): any;
 }
-type UseAxle = <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptions<V, R, P, D>) => UseAxleInstance<V, R, P, D>;
+type UseAxleOptionsWithRunnable<V = any, R = any, P = Record<string, any>, D = Record<string, any>> = UseAxleOptions<V, R, P, D> & {
+    runnable: Runnable;
+};
+interface UseAxle {
+    <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptionsWithRunnable<V, R, P, D>): UseAxleInstance<V, R | undefined, P, D>;
+    <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptions<V, R, P, D>): UseAxleInstance<V, R, P, D>;
+}
 declare function normalizeValueGetter<T>(valueGetter: T | (() => T)): T;
+declare function cleanupCacheBuffer(): void;
 declare function createUseAxle(options: CreateUseAxleOptions): UseAxle;
 
-export { CreateUseAxleOptions, ResetValueOptions, Run, RunOptions, UseAxle, UseAxleExtra, UseAxleInstance, UseAxleOptions, UseAxleRefs, createUseAxle, normalizeValueGetter, useAverageProgress, useHasLoading, useValues };
+export { CreateUseAxleOptions, ResetValueOptions, Run, RunOptions, Runnable, UseAxle, UseAxleExtra, UseAxleInstance, UseAxleOptions, UseAxleOptionsWithRunnable, UseAxleRefs, WatchOptions, cleanupCacheBuffer, createUseAxle, normalizeValueGetter, useAverageProgress, useHasLoading, useValues };