@yh-ui/request 0.1.21

package/dist/useQueue.mjs

@@ -0,0 +1,239 @@
+import { ref, reactive, computed, onUnmounted } from "vue";
+let taskIdCounter = 0;
+function generateTaskId() {
+  return `task_${Date.now()}_${++taskIdCounter}`;
+}
+export function useQueue(options = {}) {
+  const {
+    concurrency = 1,
+    autoStart = false,
+    continueOnError = false,
+    onTaskComplete,
+    onTaskError,
+    onAllComplete
+  } = options;
+  const taskList = reactive([]);
+  const taskMap = /* @__PURE__ */ new Map();
+  const isRunning = ref(false);
+  const isPaused = ref(false);
+  const currentTaskIds = /* @__PURE__ */ new Set();
+  const version = ref(0);
+  const triggerUpdate = () => {
+    version.value++;
+  };
+  const tasks = computed(() => {
+    void version.value;
+    return [...taskList];
+  });
+  const pendingTasks = computed(
+    () => tasks.value.filter((t) => t.status === "pending").sort((a, b) => (b.priority || 0) - (a.priority || 0))
+  );
+  const runningTasks = computed(() => tasks.value.filter((t) => t.status === "running"));
+  const completedTasks = computed(() => tasks.value.filter((t) => t.status === "fulfilled"));
+  const failedTasks = computed(() => tasks.value.filter((t) => t.status === "rejected"));
+  const isEmpty = computed(() => tasks.value.length === 0);
+  const isAllComplete = computed(() => {
+    if (tasks.value.length === 0) return false;
+    return tasks.value.every((t) => t.status === "fulfilled" || t.status === "rejected");
+  });
+  const completedCount = computed(() => completedTasks.value.length);
+  const totalCount = computed(() => tasks.value.length);
+  const executeTask = async (task) => {
+    if (task.status === "canceled" || task.status === "running") return;
+    task.status = "running";
+    task.startTime = Date.now();
+    currentTaskIds.add(task.id);
+    triggerUpdate();
+    try {
+      if (task.delay && task.delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, task.delay));
+      }
+      if (task.status === "canceled") return;
+      const result = await task.task();
+      if (task.status === "canceled") return;
+      task.status = "fulfilled";
+      task.result = result;
+      task.endTime = Date.now();
+      triggerUpdate();
+      onTaskComplete?.(task);
+    } catch (error) {
+      task.status = "rejected";
+      task.error = error instanceof Error ? error : new Error(String(error));
+      task.endTime = Date.now();
+      triggerUpdate();
+      onTaskError?.(task, task.error);
+      if (!continueOnError) {
+        pause();
+      }
+    } finally {
+      currentTaskIds.delete(task.id);
+    }
+  };
+  const processQueue = () => {
+    if (isPaused.value || !isRunning.value) return;
+    let launched = 0;
+    const available = concurrency - currentTaskIds.size;
+    if (available <= 0) return;
+    const pending = taskList.filter((t) => t.status === "pending").sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    for (let i = 0; i < pending.length && launched < available; i++) {
+      const nextTask = pending[i];
+      if (nextTask) {
+        launched++;
+        executeTask(nextTask).finally(() => {
+          if (isRunning.value && !isPaused.value) {
+            setTimeout(processQueue, 0);
+          }
+        });
+      }
+    }
+    if (currentTaskIds.size === 0 && pending.length === 0 && isRunning.value) {
+      isRunning.value = false;
+      onAllComplete?.(tasks.value);
+    }
+  };
+  const add = (task, addOptions = {}) => {
+    const id = generateTaskId();
+    const newTask = {
+      id,
+      key: addOptions.key,
+      task,
+      priority: addOptions.priority,
+      delay: addOptions.delay,
+      metadata: addOptions.metadata,
+      status: "pending",
+      createdAt: Date.now()
+    };
+    taskMap.set(id, newTask);
+    taskList.push(newTask);
+    triggerUpdate();
+    if (autoStart && !isRunning.value) {
+      start();
+    } else if (isRunning.value && !isPaused.value) {
+      setTimeout(processQueue, 0);
+    }
+    return id;
+  };
+  const remove = (taskId) => {
+    const task = taskMap.get(taskId);
+    if (task && task.status === "pending") {
+      task.status = "canceled";
+      taskMap.delete(taskId);
+      const index = taskList.findIndex((t) => t.id === taskId);
+      if (index > -1) taskList.splice(index, 1);
+      triggerUpdate();
+    }
+  };
+  const clear = () => {
+    taskMap.forEach((task) => {
+      if (task.status === "pending" || task.status === "running") {
+        task.status = "canceled";
+      }
+    });
+    taskMap.clear();
+    taskList.length = 0;
+    currentTaskIds.clear();
+    isRunning.value = false;
+    triggerUpdate();
+  };
+  const start = () => {
+    if (isRunning.value) return;
+    isRunning.value = true;
+    isPaused.value = false;
+    processQueue();
+  };
+  const pause = () => {
+    isPaused.value = true;
+  };
+  const resume = () => {
+    isPaused.value = false;
+    if (!isRunning.value) {
+      start();
+    } else {
+      processQueue();
+    }
+  };
+  const cancel = (taskId) => {
+    const task = taskMap.get(taskId);
+    if (task) {
+      if (task.status === "pending") {
+        task.status = "canceled";
+        taskMap.delete(taskId);
+        const index = taskList.findIndex((t) => t.id === taskId);
+        if (index > -1) taskList.splice(index, 1);
+        triggerUpdate();
+      } else if (task.status === "running") {
+        task.status = "canceled";
+        triggerUpdate();
+      }
+    }
+  };
+  const cancelAll = () => {
+    taskMap.forEach((task) => {
+      if (task.status === "pending" || task.status === "running") {
+        task.status = "canceled";
+      }
+    });
+    currentTaskIds.clear();
+    isRunning.value = false;
+    triggerUpdate();
+  };
+  const retry = (taskId) => {
+    const task = taskMap.get(taskId);
+    if (task && (task.status === "rejected" || task.status === "canceled")) {
+      task.status = "pending";
+      task.error = void 0;
+      task.result = void 0;
+      task.startTime = void 0;
+      task.endTime = void 0;
+      version.value++;
+      if (isRunning.value && !isPaused.value) {
+        setTimeout(processQueue, 0);
+      }
+    }
+  };
+  const retryAll = () => {
+    taskMap.forEach((task) => {
+      if (task.status === "rejected" || task.status === "canceled") {
+        task.status = "pending";
+        task.error = void 0;
+        task.result = void 0;
+        task.startTime = void 0;
+      }
+    });
+    triggerUpdate();
+    if (!isRunning.value) {
+      start();
+    } else if (isPaused.value) {
+      resume();
+    }
+  };
+  const getTask = (taskId) => {
+    return taskMap.get(taskId);
+  };
+  onUnmounted(() => {
+    cancelAll();
+  });
+  return {
+    tasks,
+    pendingTasks,
+    runningTasks,
+    completedTasks,
+    failedTasks,
+    isRunning,
+    isEmpty,
+    isAllComplete,
+    completedCount,
+    totalCount,
+    add,
+    remove,
+    clear,
+    start,
+    pause,
+    resume,
+    cancel,
+    cancelAll,
+    retry,
+    retryAll,
+    getTask
+  };
+}

package/dist/useRequest.cjs

@@ -0,0 +1,325 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRequest = useRequest;
+exports.useRequestPolling = useRequestPolling;
+exports.useRequestSWR = useRequestSWR;
+var _vue = require("vue");
+var _utils = require("@yh-ui/utils");
+const globalCache = /* @__PURE__ */new Map();
+function setCache(key, value, cacheTime) {
+  const expireTime = Date.now() + (cacheTime || 5 * 60 * 1e3);
+  globalCache.set(key, {
+    data: value,
+    expireTime
+  });
+}
+function useRequest(service, options = {}) {
+  const {
+    manual = false,
+    defaultParams = [],
+    debounceWait,
+    throttleWait,
+    formatResult,
+    onSuccess,
+    onError,
+    onFinally
+  } = options;
+  const loading = (0, _vue.ref)(false);
+  const loadingMore = (0, _vue.ref)(false);
+  const data = (0, _vue.shallowRef)(void 0);
+  const error = (0, _vue.shallowRef)(void 0);
+  const params = (0, _vue.ref)(defaultParams);
+  const noMore = (0, _vue.ref)(false);
+  const runCount = (0, _vue.ref)(0);
+  let abortController = null;
+  const format = response => {
+    if (formatResult) {
+      return formatResult(response);
+    }
+    if (response && typeof response === "object" && !("config" in response && "requestId" in response)) {
+      return response;
+    }
+    const res = response;
+    return res?.data ?? res;
+  };
+  const run = async (...runParams) => {
+    const currentRunCount = ++runCount.value;
+    if (abortController) {
+      abortController.abort();
+    }
+    abortController = new AbortController();
+    params.value = runParams;
+    loading.value = true;
+    error.value = void 0;
+    try {
+      const response = await service(...runParams);
+      if (currentRunCount !== runCount.value) {
+        const cancelError = new Error("Request canceled");
+        cancelError.isCanceled = true;
+        throw cancelError;
+      }
+      const formattedData = format(response);
+      data.value = formattedData;
+      if (onSuccess) {
+        onSuccess(formattedData, runParams);
+      }
+      return response;
+    } catch (err) {
+      const cancelableErr = err;
+      if (cancelableErr?.isCanceled || cancelableErr?.name === "AbortError") {
+        throw err;
+      }
+      error.value = err;
+      if (onError) {
+        onError(err, runParams);
+      }
+      throw err;
+    } finally {
+      if (currentRunCount === runCount.value) {
+        loading.value = false;
+        if (onFinally) {
+          onFinally(runParams);
+        }
+      }
+    }
+  };
+  const mutate = newData => {
+    if (typeof newData === "function") {
+      const oldData = data.value;
+      data.value = newData(oldData);
+    } else if (newData !== void 0) {
+      data.value = newData;
+    }
+  };
+  const cancel = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    loading.value = false;
+  };
+  const refresh = async () => {
+    await run(...params.value).catch(() => {});
+  };
+  const loadMore = async () => {
+    if (loadingMore.value || noMore.value) return;
+    loadingMore.value = true;
+    try {
+      await run(...params.value).catch(() => {});
+    } finally {
+      loadingMore.value = false;
+    }
+  };
+  let wrappedRun = run;
+  let cancelFn;
+  if (debounceWait) {
+    const debounced = (0, _utils.debounce)((...args) => {
+      run(...args).catch(() => {});
+    }, debounceWait);
+    wrappedRun = (...args) => {
+      debounced(...args);
+      return Promise.resolve();
+    };
+    wrappedRun.cancel = () => debounced.cancel();
+    cancelFn = () => debounced.cancel();
+  } else if (throttleWait) {
+    const throttled = (0, _utils.throttle)((...args) => {
+      run(...args).catch(() => {});
+    }, throttleWait);
+    wrappedRun = (...args) => {
+      throttled(...args);
+      return Promise.resolve();
+    };
+    wrappedRun.cancel = () => throttled.cancel();
+    cancelFn = () => throttled.cancel();
+  }
+  (0, _vue.onUnmounted)(() => {
+    cancelFn?.();
+  });
+  if (!manual && defaultParams.length > 0) {
+    (0, _vue.onMounted)(() => {
+      if (!debounceWait && !throttleWait) {
+        run(...defaultParams).catch(() => {});
+      }
+    });
+  }
+  const disabled = (0, _vue.computed)(() => loading.value);
+  return {
+    loading,
+    loadingMore,
+    data,
+    error,
+    params,
+    noMore,
+    run: wrappedRun,
+    mutate,
+    cancel,
+    refresh,
+    loadMore,
+    disabled
+  };
+}
+function useRequestSWR(cacheKey, service, options = {}) {
+  const {
+    cacheTime = 10 * 60 * 1e3,
+    setCache: customSetCache,
+    refreshOnWindowFocus = false,
+    refreshDepsWait = 1e3,
+    refreshDeps = [],
+    manual = false,
+    ...requestOptions
+  } = options;
+  const setCacheFn = customSetCache || ((key, value) => setCache(key, value, cacheTime));
+  const getKey = () => {
+    const key = typeof cacheKey === "function" ? cacheKey() : cacheKey;
+    return key;
+  };
+  const {
+    loading,
+    data,
+    error,
+    params,
+    run,
+    mutate,
+    cancel,
+    refresh,
+    disabled
+  } = useRequest(key => service(key), {
+    manual,
+    defaultParams: manual ? [] : [getKey()],
+    ...requestOptions
+  });
+  const updateCache = newData => {
+    const key = getKey();
+    if (key) {
+      setCacheFn(key, newData);
+    }
+  };
+  (0, _vue.watch)(() => data.value, newData => {
+    if (newData !== void 0) {
+      updateCache(newData);
+    }
+  }, {
+    immediate: true
+  });
+  if (refreshOnWindowFocus && !manual) {
+    (0, _vue.onMounted)(() => {
+      const handleFocus = () => {
+        const key = getKey();
+        if (key && !loading.value) {
+          refresh();
+        }
+      };
+      window.addEventListener("visibilitychange", handleFocus);
+      window.addEventListener("focus", handleFocus);
+      (0, _vue.onUnmounted)(() => {
+        window.removeEventListener("visibilitychange", handleFocus);
+        window.removeEventListener("focus", handleFocus);
+      });
+    });
+  }
+  if (refreshDeps && refreshDeps.length > 0 && !manual) {
+    (0, _vue.watch)(() => refreshDeps.map(dep => dep.value), () => {
+      const key = getKey();
+      if (key) {
+        setTimeout(() => run(key).catch(() => {}), refreshDepsWait);
+      }
+    }, {
+      deep: true
+    });
+  }
+  return {
+    loading,
+    data,
+    error,
+    params,
+    loadingMore: (0, _vue.ref)(false),
+    noMore: (0, _vue.ref)(false),
+    run,
+    mutate,
+    cancel,
+    refresh,
+    loadMore: async () => {
+      return Promise.resolve();
+    },
+    disabled
+  };
+}
+function useRequestPolling(service, options = {}) {
+  const {
+    polling = false,
+    pollingInterval = 3e3,
+    pollingWhenHidden = false,
+    ...requestOptions
+  } = options;
+  const {
+    loading,
+    data,
+    error,
+    params,
+    loadingMore,
+    noMore,
+    run,
+    mutate,
+    cancel,
+    refresh,
+    loadMore,
+    disabled
+  } = useRequest(service, {
+    manual: true,
+    ...requestOptions
+  });
+  const isPolling = (0, _vue.ref)(false);
+  const pollingTimer = (0, _vue.ref)(null);
+  const startPolling = () => {
+    if (pollingTimer.value) return;
+    isPolling.value = true;
+    run(...params.value).catch(() => {});
+    pollingTimer.value = setInterval(() => {
+      if (!pollingWhenHidden && document.hidden) {
+        return;
+      }
+      run(...params.value).catch(() => {});
+    }, pollingInterval);
+  };
+  const pause = () => {
+    if (pollingTimer.value) {
+      clearInterval(pollingTimer.value);
+      pollingTimer.value = null;
+    }
+    isPolling.value = false;
+  };
+  const resume = () => {
+    if (polling && !pollingTimer.value) {
+      startPolling();
+    }
+  };
+  (0, _vue.onUnmounted)(() => {
+    pause();
+    cancel();
+  });
+  if (polling) {
+    (0, _vue.onMounted)(() => {
+      startPolling();
+    });
+  }
+  return {
+    loading,
+    data,
+    error,
+    params,
+    loadingMore,
+    noMore,
+    run,
+    mutate,
+    cancel,
+    refresh,
+    loadMore,
+    disabled,
+    pause,
+    resume
+  };
+}

package/dist/useRequest.d.ts

@@ -0,0 +1,126 @@
+import { type Ref, type ComputedRef, type ShallowRef } from 'vue';
+import { type RequestOptions, type RequestResponse, type RequestError } from './types';
+import { Request } from './request';
+/** 请求 Hook 配置 */
+export interface UseRequestOptions<TData, TParams extends unknown[] = unknown[]> extends RequestOptions {
+    /** 手动触发 */
+    manual?: boolean;
+    /** 默认参数 */
+    defaultParams?: TParams;
+    /** 防抖等待时间 (ms) */
+    debounceWait?: number;
+    /** 节流等待时间 (ms) */
+    throttleWait?: number;
+    /** 请求实例 */
+    request?: Request;
+    /** 请求函数 */
+    service?: (...args: TParams) => Promise<RequestResponse<TData>>;
+    /** 格式化返回数据 */
+    formatResult?: (response: RequestResponse<TData>) => TData;
+    /** 成功回调 */
+    onSuccess?: (data: TData, params: TParams) => void;
+    /** 错误回调 */
+    onError?: (error: RequestError, params: TParams) => void;
+    /** 完成回调 */
+    onFinally?: (params: TParams) => void;
+}
+/** SWR 配置 */
+export interface UseRequestSWROptions<TData, TParams extends unknown[]> extends UseRequestOptions<TData, TParams> {
+    /** SWR 模式 */
+    swr?: boolean;
+    /** 缓存 key */
+    cacheKey?: string;
+    /** 缓存数据过期时间 (ms) */
+    staleTime?: number;
+    /** 缓存数据存活时间 (ms) */
+    cacheTime?: number;
+    /** 缓存数据 */
+    getCache?: (key: string) => TData | undefined;
+    /** 设置缓存 */
+    setCache?: (key: string, value: TData) => void;
+    /** 窗口聚焦重新请求 */
+    refreshOnWindowFocus?: boolean;
+    /** 重新请求防抖等待 (ms) */
+    refreshDepsWait?: number;
+    /** 依赖变化时重新请求 */
+    refreshDeps?: Ref<unknown>[];
+}
+/** 轮询配置 */
+export interface UseRequestPollingOptions<TData, TParams extends unknown[]> extends UseRequestOptions<TData, TParams> {
+    /** 轮询模式 */
+    polling?: boolean;
+    /** 轮询间隔 (ms) */
+    pollingInterval?: number;
+    /** 轮询在页面隐藏时暂停 */
+    pollingWhenHidden?: boolean;
+}
+/** 请求状态 */
+export interface UseRequestState<TData, TParams extends unknown[]> {
+    /** 加载状态 */
+    loading: Ref<boolean>;
+    /** 数据 */
+    data: ShallowRef<TData | undefined>;
+    /** 错误 */
+    error: ShallowRef<RequestError | undefined>;
+    /** 请求参数 */
+    params: Ref<TParams>;
+    /** 是否网络忙 */
+    loadingMore: Ref<boolean>;
+    /** 是否没有更多 */
+    noMore: Ref<boolean>;
+}
+/** 请求返回类型 */
+export interface UseRequestReturn<TData, TParams extends unknown[]> extends UseRequestState<TData, TParams> {
+    /** 执行请求 */
+    run: (...params: TParams) => Promise<RequestResponse<TData>>;
+    /** 手动修改数据 */
+    mutate: (newData?: TData | ((oldData?: TData) => TData)) => void;
+    /** 取消请求 */
+    cancel: () => void;
+    /** 刷新请求 */
+    refresh: () => Promise<void>;
+    /** 加载更多 */
+    loadMore: () => Promise<void>;
+    /** 按钮禁用状态 */
+    disabled: ComputedRef<boolean>;
+}
+/**
+ * useRequest - 强大的请求 Hook
+ *
+ * @example
+ * const { data, loading, error, run, refresh, cancel } = useRequest(
+ *   (id) => request.get(`/api/user/${id}`),
+ *   {
+ *     manual: false,
+ *     defaultParams: [1],
+ *     onSuccess: (data) => console.log(data),
+ *   }
+ * )
+ */
+export declare function useRequest<TData = unknown, TParams extends unknown[] = unknown[]>(service: (...args: TParams) => Promise<RequestResponse<TData>>, options?: UseRequestOptions<TData, TParams>): UseRequestReturn<TData, TParams>;
+/**
+ * useRequestSWR - 带 SWR 缓存的请求 Hook
+ *
+ * @example
+ * const { data, loading } = useRequestSWR(
+ *   () => `/api/user/${id.value}`,
+ *   (url) => request.get(url),
+ *   { cacheKey: 'user' }
+ * )
+ */
+export declare function useRequestSWR<TData = unknown>(cacheKey: string | (() => string), service: (key: string) => Promise<RequestResponse<TData>>, options?: UseRequestSWROptions<TData, [string]>): UseRequestReturn<TData, [string]>;
+/**
+ * useRequestPolling - 带轮询的请求 Hook
+ *
+ * @example
+ * const { data, pause, resume } = useRequestPolling(
+ *   () => request.get('/api/status'),
+ *   { pollingInterval: 5000 }
+ * )
+ */
+export declare function useRequestPolling<TData = unknown, TParams extends unknown[] = unknown[]>(service: (...args: TParams) => Promise<RequestResponse<TData>>, options?: UseRequestPollingOptions<TData, TParams>): UseRequestReturn<TData, TParams> & {
+    /** 暂停轮询 */
+    pause: () => void;
+    /** 恢复轮询 */
+    resume: () => void;
+};