@yh-ui/request 0.1.21

package/dist/useAIStream.d.ts

@@ -0,0 +1,89 @@
+import { type Ref } from 'vue';
+import { type UseSSEOptions, type SSEMessage } from './useSSE';
+/** AI 流式响应消息 */
+export interface AIStreamMessage {
+    /** 内容类型 */
+    type: 'text' | 'tool_call' | 'tool_result' | 'thinking' | 'done' | 'error';
+    /** 内容 */
+    content: string;
+    /** 工具调用 */
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: unknown;
+    }>;
+    /** 工具结果 */
+    toolResults?: Array<{
+        toolCallId: string;
+        result: unknown;
+    }>;
+    /** 思考内容 */
+    thinking?: string;
+    /** 元数据 */
+    metadata?: Record<string, unknown>;
+}
+/** AI 流式响应 Hook 配置 */
+export interface UseAIStreamOptions extends UseSSEOptions {
+    /** 解析 AI 消息格式 */
+    parseAIMessage?: boolean;
+    /** 文本追加模式（用于打字机效果） */
+    appendMode?: boolean;
+    /** AI 消息回调 */
+    onText?: (text: string, delta: string) => void;
+    /** 工具调用回调 */
+    onToolCall?: (toolCalls: AIStreamMessage['toolCalls']) => void;
+    /** 思考更新回调 */
+    onThinking?: (thinking: string) => void;
+}
+/** AI 流式响应 Hook 返回值 */
+export interface UseAIStreamReturn {
+    /** 是否正在加载 */
+    loading: Ref<boolean>;
+    /** 内容 */
+    content: Ref<string>;
+    /** 消息列表 */
+    messages: Ref<SSEMessage[]>;
+    /** 错误 */
+    error: Ref<Error | undefined>;
+    /** 当前文本 */
+    text: Ref<string>;
+    /** 思考内容 */
+    thinking: Ref<string>;
+    /** 工具调用列表 */
+    toolCalls: Ref<AIStreamMessage['toolCalls']>;
+    /** 是否完成 */
+    done: Ref<boolean>;
+    /** 启动流式请求 */
+    start: (options?: UseAIStreamOptions) => void;
+    /** 停止流式请求 */
+    stop: () => void;
+    /** 重置状态 */
+    reset: () => void;
+}
+/**
+ * useAIStream - AI 流式响应 Hook
+ *
+ * 专为 AI 应用设计，支持打字机效果、工具调用等
+ *
+ * @example
+ * const { text, thinking, toolCalls, done, loading, start, stop } = useAIStream({
+ *   onText: (text, delta) => {
+ *     // 打字机效果
+ *     content.value += delta
+ *   },
+ *   onThinking: (thinking) => {
+ *     // 更新思考内容
+ *   },
+ *   onToolCall: (tools) => {
+ *     // 处理工具调用
+ *   },
+ * })
+ *
+ * // 发起 AI 请求
+ * start({
+ *   url: '/api/ai/chat',
+ *   method: 'POST',
+ *   data: { messages: [...] },
+ * })
+ */
+export declare function useAIStream(options?: UseAIStreamOptions): UseAIStreamReturn;

package/dist/useAIStream.mjs

@@ -0,0 +1,108 @@
+import { ref } from "vue";
+import { useSSE } from "./useSSE.mjs";
+export function useAIStream(options = {}) {
+  const {
+    parseAIMessage = true,
+    appendMode = true,
+    onText,
+    onThinking,
+    onToolCall,
+    onMessage: userOnMessage,
+    ...sseOptions
+  } = options;
+  const text = ref("");
+  const thinking = ref("");
+  const toolCalls = ref([]);
+  const done = ref(false);
+  const handleMessage = (message) => {
+    if (!parseAIMessage) return;
+    const { event, data } = message;
+    switch (event) {
+      case "chunk":
+      case "message":
+        if (typeof data === "string") {
+          const delta = data;
+          text.value += delta;
+          onText?.(text.value, delta);
+        } else if (data !== null && typeof data === "object") {
+          const aiData = data;
+          const delta = aiData.content || aiData.text || aiData.delta || "";
+          if (delta) {
+            if (appendMode) {
+              text.value += delta;
+            } else {
+              text.value = delta;
+            }
+            onText?.(text.value, delta);
+          }
+          if (aiData.thinking) {
+            thinking.value = aiData.thinking;
+            onThinking?.(aiData.thinking);
+          }
+          if (aiData.tool_calls) {
+            toolCalls.value = aiData.tool_calls;
+            onToolCall?.(aiData.tool_calls);
+          }
+        }
+        break;
+      case "thinking":
+        if (typeof data === "string") {
+          thinking.value = data;
+          onThinking?.(data);
+        } else if (data !== null && typeof data === "object") {
+          const aiData = data;
+          const thinkContent = aiData.thinking || aiData.content || "";
+          thinking.value = thinkContent;
+          onThinking?.(thinkContent);
+        }
+        break;
+      case "tool":
+        if (data !== null && typeof data === "object") {
+          const aiData = data;
+          if (aiData.tool_calls) {
+            toolCalls.value = aiData.tool_calls;
+            onToolCall?.(aiData.tool_calls);
+          }
+        }
+        break;
+      case "done":
+        done.value = true;
+        break;
+      case "error":
+        done.value = true;
+        break;
+    }
+  };
+  const wrappedOnMessage = (msg) => {
+    handleMessage(msg);
+    userOnMessage?.(msg);
+  };
+  const { loading, content, messages, error, start, stop, reset } = useSSE({
+    ...sseOptions,
+    onMessage: wrappedOnMessage
+  });
+  const aiReset = () => {
+    text.value = "";
+    thinking.value = "";
+    toolCalls.value = [];
+    done.value = false;
+    reset();
+  };
+  const aiStart = (requestOptions) => {
+    aiReset();
+    start(requestOptions);
+  };
+  return {
+    loading,
+    content,
+    text,
+    thinking,
+    toolCalls,
+    done,
+    messages,
+    error,
+    start: aiStart,
+    stop,
+    reset: aiReset
+  };
+}

package/dist/useLoadMore.cjs

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLoadMore = useLoadMore;
+var _vue = require("vue");
+function useLoadMore(service, options = {}) {
+  const {
+    initialPage = 1,
+    pageSize: defaultPageSize = 10,
+    isLoadMore = true,
+    threshold: _threshold = 100,
+    loadMoreService,
+    onSuccess,
+    onError,
+    onFinally,
+    manual = false,
+    defaultParams = []
+  } = options;
+  const current = (0, _vue.ref)(initialPage);
+  const pageSize = (0, _vue.ref)(defaultPageSize);
+  const total = (0, _vue.ref)(0);
+  const totalPages = (0, _vue.computed)(() => {
+    if (total.value <= 0) return 0;
+    return Math.ceil(total.value / pageSize.value);
+  });
+  const data = (0, _vue.shallowRef)(void 0);
+  const loading = (0, _vue.ref)(false);
+  const refreshing = (0, _vue.ref)(false);
+  const loadingMore = (0, _vue.ref)(false);
+  const error = (0, _vue.shallowRef)(void 0);
+  const params = (0, _vue.ref)(defaultParams);
+  const noMore = (0, _vue.computed)(() => {
+    return current.value >= totalPages.value && total.value > 0;
+  });
+  const canLoadMore = (0, _vue.computed)(() => {
+    return isLoadMore && !noMore.value && !loadingMore.value;
+  });
+  const loadService = loadMoreService || service;
+  const loadData = async (isRefresh = false) => {
+    if (loading.value || loadingMore.value) return;
+    const isLoadMoreOp = !isRefresh;
+    loading.value = isLoadMoreOp ? false : true;
+    if (isRefresh) refreshing.value = true;
+    if (isLoadMoreOp) loadingMore.value = true;
+    error.value = void 0;
+    try {
+      const extraParams = params.value.slice(2);
+      const response = await loadService(current.value, pageSize.value, ...extraParams);
+      const pageData = response.data;
+      if (pageData && typeof pageData === "object") {
+        const paginatedData = pageData;
+        if (typeof paginatedData.total !== "undefined") total.value = paginatedData.total;else if (typeof paginatedData.totalCount !== "undefined") total.value = paginatedData.totalCount;else if (typeof paginatedData.totalElements !== "undefined") total.value = paginatedData.totalElements;
+      }
+      if (isRefresh) {
+        data.value = pageData;
+        current.value = initialPage + 1;
+      } else {
+        const oldData = data.value;
+        if (Array.isArray(oldData) && Array.isArray(pageData)) {
+          data.value = [...oldData, ...pageData];
+        } else {
+          data.value = pageData;
+        }
+        current.value++;
+      }
+      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 loadMore = async () => {
+    if (noMore.value || loadingMore.value) return;
+    await loadData(false);
+  };
+  const reload = async () => {
+    current.value = initialPage;
+    await loadData(true);
+  };
+  const refresh = async () => {
+    await reload();
+  };
+  const pagination = {
+    loadPage: async page => {
+      current.value = page;
+      await loadData(true);
+    },
+    nextPage: loadMore,
+    prevPage: async () => {
+      await pagination.loadPage(current.value - 1);
+    },
+    firstPage: async () => {
+      await pagination.loadPage(1);
+    },
+    lastPage: async () => {
+      await pagination.loadPage(totalPages.value);
+    },
+    refresh: reload,
+    setPageSize: size => {
+      pageSize.value = size;
+    },
+    setTotal: newTotal => {
+      total.value = newTotal;
+    }
+  };
+  if (!manual) {
+    (0, _vue.onMounted)(() => {
+      loadData();
+    });
+  }
+  return {
+    current,
+    pageSize,
+    total,
+    totalPages,
+    data,
+    loading,
+    refreshing,
+    loadingMore,
+    error,
+    params,
+    noMore,
+    canLoadMore,
+    loadMore,
+    reload,
+    refresh,
+    pagination
+  };
+}

package/dist/useLoadMore.d.ts

@@ -0,0 +1,84 @@
+import { type Ref, type ShallowRef } from 'vue';
+import { type RequestResponse } from './types';
+/**
+ * useLoadMore - 无限滚动加载更多 Hook
+ *
+ * @example
+ * const {
+ *   data, loading, loadingMore, noMore,
+ *   loadMore, refresh, reload
+ * } = useLoadMore(
+ *   (page, size) => request.get('/api/list', { params: { page, size } }),
+ *   { initialPage: 1, pageSize: 10 }
+ * )
+ */
+/** 加载更多配置 */
+export interface UseLoadMoreOptions<TData, TParams extends unknown[] = unknown[]> {
+    /** 请求函数（当作为第一个参数传入时可省略） */
+    service?: (page: number, pageSize: number, ...args: TParams) => Promise<RequestResponse<TData>>;
+    /** 初始页码 */
+    initialPage?: number;
+    /** 每页条数 */
+    pageSize?: number;
+    /** 是否在底部触发加载 */
+    isLoadMore?: boolean;
+    /** 距离底部多少像素触发加载 */
+    threshold?: number;
+    /** 加载更多的请求函数（可以与 service 不同） */
+    loadMoreService?: (page: number, pageSize: number) => Promise<RequestResponse<TData>>;
+    /** 成功回调 */
+    onSuccess?: (data: TData, params: TParams) => void;
+    /** 错误回调 */
+    onError?: (error: unknown, params: TParams) => void;
+    /** 完成后回调 */
+    onFinally?: (params: TParams) => void;
+    /** 是否手动触发 */
+    manual?: boolean;
+    /** 默认参数 */
+    defaultParams?: TParams;
+}
+/** 加载更多返回 */
+export interface UseLoadMoreReturn<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>;
+    /** 加载更多状态 */
+    loadingMore: Ref<boolean>;
+    /** 错误 */
+    error: ShallowRef<unknown>;
+    /** 请求参数 */
+    params: Ref<TParams>;
+    /** 是否没有更多 */
+    noMore: Ref<boolean>;
+    /** 是否可以加载更多 */
+    canLoadMore: Ref<boolean>;
+    /** 加载更多 */
+    loadMore: () => Promise<void>;
+    /** 重新加载（重置分页） */
+    reload: () => Promise<void>;
+    /** 刷新 */
+    refresh: () => Promise<void>;
+    /** 分页方法 */
+    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;
+    };
+}
+export declare function useLoadMore<TData = unknown, TParams extends unknown[] = unknown[]>(service: (page: number, pageSize: number, ...args: TParams) => Promise<RequestResponse<TData>>, options?: UseLoadMoreOptions<TData, TParams>): UseLoadMoreReturn<TData, TParams>;

package/dist/useLoadMore.mjs

@@ -0,0 +1,134 @@
+import { ref, shallowRef, computed, onMounted } from "vue";
+export function useLoadMore(service, options = {}) {
+  const {
+    initialPage = 1,
+    pageSize: defaultPageSize = 10,
+    isLoadMore = true,
+    threshold: _threshold = 100,
+    loadMoreService,
+    onSuccess,
+    onError,
+    onFinally,
+    manual = false,
+    defaultParams = []
+  } = options;
+  const current = ref(initialPage);
+  const pageSize = ref(defaultPageSize);
+  const total = ref(0);
+  const totalPages = computed(() => {
+    if (total.value <= 0) return 0;
+    return Math.ceil(total.value / pageSize.value);
+  });
+  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 noMore = computed(() => {
+    return current.value >= totalPages.value && total.value > 0;
+  });
+  const canLoadMore = computed(() => {
+    return isLoadMore && !noMore.value && !loadingMore.value;
+  });
+  const loadService = loadMoreService || service;
+  const loadData = async (isRefresh = false) => {
+    if (loading.value || loadingMore.value) return;
+    const isLoadMoreOp = !isRefresh;
+    loading.value = isLoadMoreOp ? false : true;
+    if (isRefresh) refreshing.value = true;
+    if (isLoadMoreOp) loadingMore.value = true;
+    error.value = void 0;
+    try {
+      const extraParams = params.value.slice(2);
+      const response = await loadService(current.value, pageSize.value, ...extraParams);
+      const pageData = response.data;
+      if (pageData && typeof pageData === "object") {
+        const paginatedData = pageData;
+        if (typeof paginatedData.total !== "undefined") total.value = paginatedData.total;
+        else if (typeof paginatedData.totalCount !== "undefined")
+          total.value = paginatedData.totalCount;
+        else if (typeof paginatedData.totalElements !== "undefined")
+          total.value = paginatedData.totalElements;
+      }
+      if (isRefresh) {
+        data.value = pageData;
+        current.value = initialPage + 1;
+      } else {
+        const oldData = data.value;
+        if (Array.isArray(oldData) && Array.isArray(pageData)) {
+          data.value = [...oldData, ...pageData];
+        } else {
+          data.value = pageData;
+        }
+        current.value++;
+      }
+      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 loadMore = async () => {
+    if (noMore.value || loadingMore.value) return;
+    await loadData(false);
+  };
+  const reload = async () => {
+    current.value = initialPage;
+    await loadData(true);
+  };
+  const refresh = async () => {
+    await reload();
+  };
+  const pagination = {
+    loadPage: async (page) => {
+      current.value = page;
+      await loadData(true);
+    },
+    nextPage: loadMore,
+    prevPage: async () => {
+      await pagination.loadPage(current.value - 1);
+    },
+    firstPage: async () => {
+      await pagination.loadPage(1);
+    },
+    lastPage: async () => {
+      await pagination.loadPage(totalPages.value);
+    },
+    refresh: reload,
+    setPageSize: (size) => {
+      pageSize.value = size;
+    },
+    setTotal: (newTotal) => {
+      total.value = newTotal;
+    }
+  };
+  if (!manual) {
+    onMounted(() => {
+      loadData();
+    });
+  }
+  return {
+    current,
+    pageSize,
+    total,
+    totalPages,
+    data,
+    loading,
+    refreshing,
+    loadingMore,
+    error,
+    params,
+    noMore,
+    canLoadMore,
+    loadMore,
+    reload,
+    refresh,
+    pagination
+  };
+}

package/dist/usePagination.cjs

@@ -0,0 +1,141 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePagination = usePagination;
+var _vue = require("vue");
+function usePagination(service, options = {}) {
+  const {
+    defaultPagination = {
+      current: 1,
+      pageSize: 10
+    },
+    onSuccess,
+    onError,
+    onFinally,
+    manual = false,
+    defaultParams = []
+  } = options;
+  const current = (0, _vue.ref)(defaultPagination.current || 1);
+  const pageSize = (0, _vue.ref)(defaultPagination.pageSize || 10);
+  const total = (0, _vue.ref)(defaultPagination.total || 0);
+  const totalPages = (0, _vue.computed)(() => {
+    if (total.value <= 0) return 0;
+    return Math.ceil(total.value / pageSize.value);
+  });
+  const noMore = (0, _vue.computed)(() => {
+    return current.value >= totalPages.value && total.value > 0;
+  });
+  const data = (0, _vue.shallowRef)(void 0);
+  const loading = (0, _vue.ref)(false);
+  const refreshing = (0, _vue.ref)(false);
+  const loadingMore = (0, _vue.ref)(false);
+  const error = (0, _vue.shallowRef)(void 0);
+  const params = (0, _vue.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;
+  };
+  (0, _vue.watch)(pageSize, () => {
+    if (!manual) {
+      current.value = 1;
+      loadData();
+    }
+  });
+  (0, _vue.watch)(current, () => {
+    if (!manual) {
+      loadData();
+    }
+  });
+  if (!manual) {
+    (0, _vue.onMounted)(() => {
+      loadData();
+    });
+  }
+  return {
+    current,
+    pageSize,
+    total,
+    totalPages,
+    data,
+    loading,
+    refreshing,
+    loadingMore,
+    error,
+    params,
+    noMore,
+    pagination: {
+      loadPage,
+      nextPage,
+      prevPage,
+      firstPage,
+      lastPage,
+      refresh,
+      setPageSize,
+      setTotal
+    }
+  };
+}