@varlet/axle 0.11.2 → 0.13.0

package/lib/use.js

@@ -3,27 +3,29 @@ import {
 } from "./chunk-G2ADBYYC.js";
 
 // src/use.ts
-import { getCurrentInstance, onUnmounted, ref as ref3 } from "vue";
+import { getCurrentInstance, onActivated, onDeactivated, onMounted, onUnmounted, ref as ref3, watch as watch3 } from "vue";
 import { isFunction } from "rattail";
 
-// src/composables/useValues.ts
-import { computed } from "vue";
-function useValues(...valueCollection) {
-  return computed({
-    get: () => valueCollection.map((value) => value.value),
-    set(values) {
-      valueCollection.forEach((value, index) => {
-        value.value = values[index];
-      });
-    }
-  });
+// src/composables/useAverageProgress.ts
+import { ref, watch } from "vue";
+function useAverageProgress(...progressCollection) {
+  const averageProgress = ref(0);
+  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
-import { ref, watch } from "vue";
+import { ref as ref2, watch as watch2 } from "vue";
 function useHasLoading(...loadings) {
-  const hasLoading = ref(false);
-  watch(
+  const hasLoading = ref2(false);
+  watch2(
     () => loadings.map((loading) => loading.value),
     (newLoadings) => {
       hasLoading.value = newLoadings.some(Boolean);
@@ -33,31 +35,38 @@ function useHasLoading(...loadings) {
   return hasLoading;
 }
 
-// src/composables/useAverageProgress.ts
-import { ref as ref2, watch as watch2 } from "vue";
-function useAverageProgress(...progressCollection) {
-  const averageProgress = ref2(0);
-  watch2(
-    () => 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/useValues.ts
+import { computed } from "vue";
+function useValues(...valueCollection) {
+  return computed({
+    get: () => valueCollection.map((value) => value.value),
+    set(values) {
+      valueCollection.forEach((value, index) => {
+        value.value = values[index];
+      });
+    }
+  });
 }
 
 // src/use.ts
 function normalizeValueGetter(valueGetter) {
   return 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 {
@@ -65,11 +74,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 = () => {
@@ -85,86 +102,182 @@ function createUseAxle(options) {
     const error = ref3();
     const downloadProgress = ref3(0);
     const uploadProgress = ref3(0);
+    const pollingCanceled = ref3(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 (getCurrentInstance()) {
+      onActivated(() => {
+        deactivated = false;
+        addVisibilityChangeListener();
+        addWindowFocusListener();
+        startPolling();
+      });
+      onMounted(() => {
+        addVisibilityChangeListener();
+        addWindowFocusListener();
+      });
+      onDeactivated(() => {
+        deactivated = true;
+        removeVisibilityChangeListener();
+        removeWindowFocusListener();
+        clearPolling();
+      });
+      onUnmounted(() => {
+        removeVisibilityChangeListener();
+        removeWindowFocusListener();
+        cancelPolling();
+      });
+      if (abortOnUnmount) {
+        onUnmounted(() => {
+          abort();
+        });
+      }
+      if (watchOptions) {
+        const normalizedWatchOptions = watchOptions === true ? { params: true, config: true } : __spreadValues({ params: false, config: false }, watchOptions);
+        const enableWatchParams = isFunction(initialParamsOrGetter) && normalizedWatchOptions.params;
+        const enableWatchConfig = isFunction(initialConfigOrGetter) && normalizedWatchOptions.config;
+        watch3(
+          () => [
+            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 && getCurrentInstance()) {
-      onUnmounted(() => {
-        abort();
-      });
-    }
     function resetValue(options3 = {}) {
       var _a, _b;
       const cloneResetValue = (_b = (_a = options3.cloneResetValue) != null ? _a : initialCloneResetValue) != null ? _b : false;
@@ -174,11 +287,70 @@ 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;
 }
 export {
+  cleanupCacheBuffer,
   createUseAxle,
   normalizeValueGetter,
   useAverageProgress,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/axle",
-  "version": "0.11.2",
+  "version": "0.13.0",
   "description": "Progressive request tool based on axios",
   "keywords": [
     "axle",
@@ -55,14 +55,12 @@
     "axios": "^1.7.3",
     "crypto-js": "^4.2.0",
     "lodash": "4.17.21",
-    "minimatch": "^9.0.3",
     "qs": "^6.11.0",
     "rattail": "1.0.0"
   },
   "devDependencies": {
     "@types/crypto-js": "^4.2.1",
     "@types/lodash": "4.14.202",
-    "@types/minimatch": "^5.1.2",
     "@types/qs": "^6.9.7",
     "tsup": "7.2.0",
     "typescript": "^5.1.5",