@yh-ui/request 0.1.21

package/dist/usePagination.d.ts

@@ -0,0 +1,89 @@
+import { type Ref, type ShallowRef } from 'vue';
+import { type RequestResponse } from './types';
+/** 分页参数 */
+export interface PaginationOptions {
+    /** 当前页码 */
+    current?: number;
+    /** 每页条数 */
+    pageSize?: number;
+    /** 总数 */
+    total?: number;
+    /** 总页数 */
+    totalPages?: number;
+}
+/** 分页 Hook 配置 */
+export interface UsePaginationOptions<TData, TParams extends unknown[] = unknown[]> {
+    /** 请求函数（当作为第一个参数传入时可省略） */
+    service?: (...args: TParams) => Promise<RequestResponse<TData>>;
+    /** 默认分页配置 */
+    defaultPagination?: PaginationOptions;
+    /** 请求实例 */
+    request?: Request;
+    /** 成功回调 */
+    onSuccess?: (data: TData, params: TParams) => void;
+    /** 错误回调 */
+    onError?: (error: unknown, params: TParams) => void;
+    /** 完成后回调 */
+    onFinally?: (params: TParams) => void;
+    /** 是否手动触发 */
+    manual?: boolean;
+    /** 默认参数 */
+    defaultParams?: TParams;
+}
+/** 分页 Hook 返回值 */
+export interface UsePaginationReturn<TData, TParams extends unknown[] = unknown[]> {
+    /** 当前页码 */
+    current: Ref<number>;
+    /** 每页条数 */
+    pageSize: Ref<number>;
+    /** 总数 */
+    total: Ref<number>;
+    /** 总页数 */
+    totalPages: Ref<number>;
+    /** 数据 */
+    data: ShallowRef<TData | undefined>;
+    /** 加载状态 */
+    loading: Ref<boolean>;
+    /** 刷新状态 */
+    refreshing: Ref<boolean>;
+    /** 请求参数 */
+    params: Ref<TParams>;
+    /** 错误 */
+    error: ShallowRef<unknown>;
+    /** 是否还有更多 */
+    noMore: Ref<boolean>;
+    /** 加载中 */
+    loadingMore: Ref<boolean>;
+    /** 分页方法 */
+    pagination: {
+        /** 加载指定页 */
+        loadPage: (page: number) => Promise<void>;
+        /** 下一页 */
+        nextPage: () => Promise<void>;
+        /** 上一页 */
+        prevPage: () => Promise<void>;
+        /** 首页 */
+        firstPage: () => Promise<void>;
+        /** 末页 */
+        lastPage: () => Promise<void>;
+        /** 刷新 */
+        refresh: () => Promise<void>;
+        /** 设置每页条数 */
+        setPageSize: (size: number) => void;
+        /** 设置总数 */
+        setTotal: (total: number) => void;
+    };
+}
+/**
+ * usePagination - 分页请求 Hook
+ *
+ * @example
+ * const {
+ *   current, pageSize, total, data, loading,
+ *   pagination: { loadPage, nextPage, prevPage, refresh }
+ * } = usePagination(
+ *   (page, size) => request.get('/api/list', { params: { page, size } }),
+ *   { defaultPagination: { current: 1, pageSize: 10 } }
+ * )
+ */
+export declare function usePagination<TData = unknown, TParams extends unknown[] = [number, number]>(service: (current: number, pageSize: number, ...args: unknown[]) => Promise<RequestResponse<TData>>, options?: UsePaginationOptions<TData, TParams>): UsePaginationReturn<TData, TParams>;

package/dist/usePagination.mjs

@@ -0,0 +1,132 @@
+import { ref, shallowRef, computed, watch, onMounted } from "vue";
+export function usePagination(service, options = {}) {
+  const {
+    defaultPagination = { current: 1, pageSize: 10 },
+    onSuccess,
+    onError,
+    onFinally,
+    manual = false,
+    defaultParams = []
+  } = options;
+  const current = ref(defaultPagination.current || 1);
+  const pageSize = ref(defaultPagination.pageSize || 10);
+  const total = ref(defaultPagination.total || 0);
+  const totalPages = computed(() => {
+    if (total.value <= 0) return 0;
+    return Math.ceil(total.value / pageSize.value);
+  });
+  const noMore = computed(() => {
+    return current.value >= totalPages.value && total.value > 0;
+  });
+  const data = shallowRef(void 0);
+  const loading = ref(false);
+  const refreshing = ref(false);
+  const loadingMore = ref(false);
+  const error = shallowRef(void 0);
+  const params = ref(defaultParams);
+  const loadData = async () => {
+    if (loading.value) return;
+    loading.value = true;
+    error.value = void 0;
+    try {
+      const page = current.value;
+      const size = pageSize.value;
+      const extraParams = params.value.slice(2);
+      const response = await service(page, size, ...extraParams);
+      const pageData = response.data;
+      if (pageData && typeof pageData === "object") {
+        const paginatedData = pageData;
+        if (typeof paginatedData.total !== "undefined") {
+          total.value = paginatedData.total;
+        }
+        if (typeof paginatedData.totalCount !== "undefined") {
+          total.value = paginatedData.totalCount;
+        }
+        if (typeof paginatedData.totalElements !== "undefined") {
+          total.value = paginatedData.totalElements;
+        }
+      }
+      data.value = pageData;
+      onSuccess?.(pageData, params.value);
+    } catch (err) {
+      error.value = err;
+      onError?.(err, params.value);
+    } finally {
+      loading.value = false;
+      refreshing.value = false;
+      loadingMore.value = false;
+      onFinally?.(params.value);
+    }
+  };
+  const loadPage = async (page) => {
+    if (page < 1 || totalPages.value > 0 && page > totalPages.value) return;
+    current.value = page;
+    await loadData();
+  };
+  const nextPage = async () => {
+    if (noMore.value) return;
+    await loadPage(current.value + 1);
+  };
+  const prevPage = async () => {
+    await loadPage(current.value - 1);
+  };
+  const firstPage = async () => {
+    await loadPage(1);
+  };
+  const lastPage = async () => {
+    await loadPage(totalPages.value);
+  };
+  const refresh = async () => {
+    current.value = 1;
+    refreshing.value = true;
+    await loadData();
+  };
+  const setPageSize = (size) => {
+    pageSize.value = size;
+    if (!manual) {
+      refresh();
+    }
+  };
+  const setTotal = (newTotal) => {
+    total.value = newTotal;
+  };
+  watch(pageSize, () => {
+    if (!manual) {
+      current.value = 1;
+      loadData();
+    }
+  });
+  watch(current, () => {
+    if (!manual) {
+      loadData();
+    }
+  });
+  if (!manual) {
+    onMounted(() => {
+      loadData();
+    });
+  }
+  return {
+    current,
+    pageSize,
+    total,
+    totalPages,
+    data,
+    loading,
+    refreshing,
+    loadingMore,
+    error,
+    params,
+    noMore,
+    pagination: {
+      loadPage,
+      nextPage,
+      prevPage,
+      firstPage,
+      lastPage,
+      refresh,
+      setPageSize,
+      setTotal
+    }
+  };
+}

package/dist/useQueue.cjs

@@ -0,0 +1,243 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useQueue = useQueue;
+var _vue = require("vue");
+let taskIdCounter = 0;
+function generateTaskId() {
+  return `task_${Date.now()}_${++taskIdCounter}`;
+}
+function useQueue(options = {}) {
+  const {
+    concurrency = 1,
+    autoStart = false,
+    continueOnError = false,
+    onTaskComplete,
+    onTaskError,
+    onAllComplete
+  } = options;
+  const taskList = (0, _vue.reactive)([]);
+  const taskMap = /* @__PURE__ */new Map();
+  const isRunning = (0, _vue.ref)(false);
+  const isPaused = (0, _vue.ref)(false);
+  const currentTaskIds = /* @__PURE__ */new Set();
+  const version = (0, _vue.ref)(0);
+  const triggerUpdate = () => {
+    version.value++;
+  };
+  const tasks = (0, _vue.computed)(() => {
+    void version.value;
+    return [...taskList];
+  });
+  const pendingTasks = (0, _vue.computed)(() => tasks.value.filter(t => t.status === "pending").sort((a, b) => (b.priority || 0) - (a.priority || 0)));
+  const runningTasks = (0, _vue.computed)(() => tasks.value.filter(t => t.status === "running"));
+  const completedTasks = (0, _vue.computed)(() => tasks.value.filter(t => t.status === "fulfilled"));
+  const failedTasks = (0, _vue.computed)(() => tasks.value.filter(t => t.status === "rejected"));
+  const isEmpty = (0, _vue.computed)(() => tasks.value.length === 0);
+  const isAllComplete = (0, _vue.computed)(() => {
+    if (tasks.value.length === 0) return false;
+    return tasks.value.every(t => t.status === "fulfilled" || t.status === "rejected");
+  });
+  const completedCount = (0, _vue.computed)(() => completedTasks.value.length);
+  const totalCount = (0, _vue.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);
+  };
+  (0, _vue.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/useQueue.d.ts

@@ -0,0 +1,118 @@
+import { type Ref, type ComputedRef } from 'vue';
+/** 队列任务状态 */
+export type QueueTaskStatus = 'pending' | 'running' | 'fulfilled' | 'rejected' | 'canceled';
+/** 队列任务 */
+export interface QueueTask<T = unknown> {
+    /** 任务 ID */
+    id: string;
+    /** 任务 key（用于去重） */
+    key?: string;
+    /** 任务函数 */
+    task: () => Promise<T>;
+    /** 任务优先级（数字越大优先级越高） */
+    priority?: number;
+    /** 任务状态 */
+    status: QueueTaskStatus;
+    /** 任务结果 */
+    result?: T;
+    /** 任务错误 */
+    error?: Error;
+    /** 任务元数据 */
+    metadata?: Record<string, unknown>;
+    /** 开始时间 */
+    startTime?: number;
+    /** 结束时间 */
+    endTime?: number;
+    /** 延迟时间 (ms) */
+    delay?: number;
+    /** 创建时间 */
+    createdAt: number;
+}
+/** 队列配置 */
+export interface UseQueueOptions {
+    /** 最大并发数 */
+    concurrency?: number;
+    /** 是否自动开始 */
+    autoStart?: boolean;
+    /** 任务失败时是否继续 */
+    continueOnError?: boolean;
+    /** 任务完成回调 */
+    onTaskComplete?: <T>(task: QueueTask<T>) => void;
+    /** 任务错误回调 */
+    onTaskError?: <T>(task: QueueTask<T>, error: Error) => void;
+    /** 所有任务完成回调 */
+    onAllComplete?: <T>(tasks: QueueTask<T>[]) => void;
+}
+/** 添加任务选项 */
+export interface AddTaskOptions {
+    key?: string;
+    priority?: number;
+    delay?: number;
+    metadata?: Record<string, unknown>;
+}
+/** 队列 Hook 返回值 */
+export interface UseQueueReturn<T = unknown> {
+    /** 队列任务列表 */
+    tasks: ComputedRef<QueueTask<T>[]>;
+    /** 待执行的任务 */
+    pendingTasks: ComputedRef<QueueTask<T>[]>;
+    /** 正在执行的任务 */
+    runningTasks: ComputedRef<QueueTask<T>[]>;
+    /** 已完成的任务 */
+    completedTasks: ComputedRef<QueueTask<T>[]>;
+    /** 失败的任务 */
+    failedTasks: ComputedRef<QueueTask<T>[]>;
+    /** 队列是否正在运行 */
+    isRunning: Ref<boolean>;
+    /** 队列是否为空 */
+    isEmpty: ComputedRef<boolean>;
+    /** 队列是否全部完成 */
+    isAllComplete: ComputedRef<boolean>;
+    /** 已完成数量 */
+    completedCount: ComputedRef<number>;
+    /** 总数量 */
+    totalCount: ComputedRef<number>;
+    /** 添加任务 */
+    add: <R = unknown>(task: () => Promise<R>, options?: AddTaskOptions) => string;
+    /** 移除任务 */
+    remove: (taskId: string) => void;
+    /** 清空队列 */
+    clear: () => void;
+    /** 开始执行队列 */
+    start: () => void;
+    /** 暂停队列 */
+    pause: () => void;
+    /** 继续队列 */
+    resume: () => void;
+    /** 取消任务 */
+    cancel: (taskId: string) => void;
+    /** 取消所有任务 */
+    cancelAll: () => void;
+    /** 重试任务 */
+    retry: (taskId: string) => void;
+    /** 重试所有失败任务 */
+    retryAll: () => void;
+    /** 获取任务 */
+    getTask: (taskId: string) => QueueTask<T> | undefined;
+}
+/**
+ * useQueue - 请求队列管理 Hook
+ *
+ * 支持并发控制、优先级、延迟执行、失败重试等功能
+ *
+ * @example
+ * const {
+ *   tasks, pendingTasks, runningTasks, isRunning,
+ *   add, remove, start, pause, clear
+ * } = useQueue({
+ *   concurrency: 3,
+ *   autoStart: true,
+ * })
+ *
+ * // 添加任务
+ * add(async () => {
+ *   const res = await request.get('/api/item/1')
+ *   return res.data
+ * }, { priority: 1 })
+ */
+export declare function useQueue<T = unknown>(options?: UseQueueOptions): UseQueueReturn<T>;