@slan-health/taro-vueuse/dist/useRequest/core/plugins/useLoadingDelayPlugin.js

taro vue版本hooks

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { ref, computed } from "vue";
import { definePlugin } from "../definePlugin.js";
import { refToRaw } from "../utils/index.js";
function setTimeoutPromise(duration) {
  let timerId, stop;
  class Timer extends Promise {
    constructor(fn) {
      super(fn);
      __publicField(this, "cancel", () => {
        stop();
        clearTimeout(timerId);
      });
    }
  }
  return new Timer((resolve) => {
    stop = resolve;
    timerId = setTimeout(stop, duration);
  });
}
function getCurrentTime() {
  return (/* @__PURE__ */ new Date()).getTime();
}
const useLoadingDelayPlugin = definePlugin(
  (queryInstance, { loadingDelay = 0, loadingKeep = 0 }) => {
    const delayLoadingTimer = ref(() => {
    });
    const loadingDelayRef = computed(() => refToRaw(loadingDelay));
    const loadingKeepRef = computed(() => refToRaw(loadingKeep));
    let startTime = 0;
    let timeoutPromise = {};
    const delayLoading = () => {
      let timerId;
      if (loadingDelayRef.value) {
        timerId = setTimeout(() => {
          if (queryInstance.status.value === "pending") {
            queryInstance.loading.value = true;
          }
        }, loadingDelayRef.value);
      }
      return () => timerId && clearTimeout(timerId);
    };
    return {
      onBefore() {
        queryInstance.loading.value = !loadingDelayRef.value;
        delayLoadingTimer.value();
        delayLoadingTimer.value = delayLoading();
        startTime = getCurrentTime();
      },
      onQuery(service) {
        if (!loadingKeepRef.value) return () => service();
        timeoutPromise = setTimeoutPromise(
          loadingKeepRef.value + loadingDelayRef.value
        );
        const _service = async () => {
          try {
            const res = await service();
            if (getCurrentTime() - startTime <= loadingDelayRef.value) {
              timeoutPromise.cancel();
            }
            return Promise.resolve(res);
          } catch (error) {
            if (getCurrentTime() - startTime <= loadingDelayRef.value) {
              timeoutPromise.cancel();
            }
            return Promise.reject(error);
          }
        };
        const servicePromise = Promise.allSettled([
          _service(),
          timeoutPromise
        ]).then((res) => {
          const result = res[0];
          if (result.status === "fulfilled") {
            return result.value;
          } else {
            return Promise.reject(result.reason);
          }
        });
        return () => servicePromise;
      },
      onCancel() {
        delayLoadingTimer.value();
      },
      onAfter() {
        delayLoadingTimer.value();
      }
    };
  }
);
export {
  useLoadingDelayPlugin as default
};
//# sourceMappingURL=useLoadingDelayPlugin.js.map