@yh-ui/request 0.1.21

package/dist/useRequest.mjs

@@ -0,0 +1,329 @@
+import {
+  ref,
+  shallowRef,
+  computed,
+  watch,
+  onMounted,
+  onUnmounted
+} from "vue";
+import { debounce, throttle } from "@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 });
+}
+export function useRequest(service, options = {}) {
+  const {
+    manual = false,
+    defaultParams = [],
+    debounceWait,
+    throttleWait,
+    formatResult,
+    onSuccess,
+    onError,
+    onFinally
+  } = options;
+  const loading = ref(false);
+  const loadingMore = ref(false);
+  const data = shallowRef(void 0);
+  const error = shallowRef(void 0);
+  const params = ref(defaultParams);
+  const noMore = ref(false);
+  const runCount = 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 = 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 = throttle(
+      ((...args) => {
+        run(...args).catch(() => {
+        });
+      }),
+      throttleWait
+    );
+    wrappedRun = ((...args) => {
+      throttled(...args);
+      return Promise.resolve();
+    });
+    wrappedRun.cancel = () => throttled.cancel();
+    cancelFn = () => throttled.cancel();
+  }
+  onUnmounted(() => {
+    cancelFn?.();
+  });
+  if (!manual && defaultParams.length > 0) {
+    onMounted(() => {
+      if (!debounceWait && !throttleWait) {
+        run(...defaultParams).catch(() => {
+        });
+      }
+    });
+  }
+  const disabled = computed(() => loading.value);
+  return {
+    loading,
+    loadingMore,
+    data,
+    error,
+    params,
+    noMore,
+    run: wrappedRun,
+    mutate,
+    cancel,
+    refresh,
+    loadMore,
+    disabled
+  };
+}
+export 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);
+    }
+  };
+  watch(
+    () => data.value,
+    (newData) => {
+      if (newData !== void 0) {
+        updateCache(newData);
+      }
+    },
+    { immediate: true }
+  );
+  if (refreshOnWindowFocus && !manual) {
+    onMounted(() => {
+      const handleFocus = () => {
+        const key = getKey();
+        if (key && !loading.value) {
+          refresh();
+        }
+      };
+      window.addEventListener("visibilitychange", handleFocus);
+      window.addEventListener("focus", handleFocus);
+      onUnmounted(() => {
+        window.removeEventListener("visibilitychange", handleFocus);
+        window.removeEventListener("focus", handleFocus);
+      });
+    });
+  }
+  if (refreshDeps && refreshDeps.length > 0 && !manual) {
+    watch(
+      () => refreshDeps.map((dep) => dep.value),
+      () => {
+        const key = getKey();
+        if (key) {
+          setTimeout(() => run(key).catch(() => {
+          }), refreshDepsWait);
+        }
+      },
+      { deep: true }
+    );
+  }
+  return {
+    loading,
+    data,
+    error,
+    params,
+    loadingMore: ref(false),
+    noMore: ref(false),
+    run,
+    mutate,
+    cancel,
+    refresh,
+    loadMore: async () => {
+      return Promise.resolve();
+    },
+    disabled
+  };
+}
+export 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 = ref(false);
+  const pollingTimer = 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();
+    }
+  };
+  onUnmounted(() => {
+    pause();
+    cancel();
+  });
+  if (polling) {
+    onMounted(() => {
+      startPolling();
+    });
+  }
+  return {
+    loading,
+    data,
+    error,
+    params,
+    loadingMore,
+    noMore,
+    run,
+    mutate,
+    cancel,
+    refresh,
+    loadMore,
+    disabled,
+    pause,
+    resume
+  };
+}

package/dist/useRequestQueue.cjs

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRequestQueue = useRequestQueue;
+var _useQueue = require("./useQueue.cjs");
+function useRequestQueue(options = {}) {
+  const {
+    request: _customRequest,
+    ...queueOptions
+  } = options;
+  const queue = (0, _useQueue.useQueue)(queueOptions);
+  const addRequest = (requestFn, addOptions = {}) => {
+    return queue.add(requestFn, {
+      ...addOptions,
+      metadata: {
+        ...addOptions.metadata,
+        type: "request"
+      }
+    });
+  };
+  const cancelByKey = key => {
+    const pending = queue.pendingTasks.value ?? [];
+    const running = queue.runningTasks.value ?? [];
+    const task = [...pending, ...running].find(t => t.key === key);
+    if (task) {
+      queue.cancel(task.id);
+    }
+  };
+  return {
+    ...queue,
+    addRequest,
+    cancelByKey
+  };
+}

package/dist/useRequestQueue.d.ts

@@ -0,0 +1,52 @@
+import { useQueue, type UseQueueOptions, type QueueTask } from './useQueue';
+/**
+ * useRequestQueue - 请求队列 Hook
+ *
+ * 专用于 HTTP 请求的队列管理，支持并发限制、优先级
+ *
+ * @example
+ * const { addRequest, cancelByKey } = useRequestQueue({
+ *   concurrency: 2,
+ * })
+ *
+ * addRequest(() => request.get('/api/item/1'), { key: 'item-1' })
+ */
+/** 请求队列配置 */
+export interface UseRequestQueueOptions extends UseQueueOptions {
+    /** 请求实例 */
+    request?: unknown;
+}
+/** 请求队列返回 */
+export interface UseRequestQueueReturn {
+    tasks: ReturnType<typeof useQueue>['tasks'];
+    pendingTasks: ReturnType<typeof useQueue>['pendingTasks'];
+    runningTasks: ReturnType<typeof useQueue>['runningTasks'];
+    completedTasks: ReturnType<typeof useQueue>['completedTasks'];
+    failedTasks: ReturnType<typeof useQueue>['failedTasks'];
+    isRunning: ReturnType<typeof useQueue>['isRunning'];
+    isEmpty: ReturnType<typeof useQueue>['isEmpty'];
+    isAllComplete: ReturnType<typeof useQueue>['isAllComplete'];
+    completedCount: ReturnType<typeof useQueue>['completedCount'];
+    totalCount: ReturnType<typeof useQueue>['totalCount'];
+    addRequest: <T = unknown>(requestFn: () => Promise<T>, options?: {
+        key?: string;
+        priority?: number;
+        delay?: number;
+        metadata?: Record<string, unknown>;
+    }) => string;
+    cancelByKey: (key: string) => void;
+    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 | undefined;
+}
+/**
+ * useRequestQueue - HTTP 请求队列 Hook
+ */
+export declare function useRequestQueue(options?: UseRequestQueueOptions): UseRequestQueueReturn;

package/dist/useRequestQueue.mjs

@@ -0,0 +1,27 @@
+import { useQueue } from "./useQueue.mjs";
+export function useRequestQueue(options = {}) {
+  const { request: _customRequest, ...queueOptions } = options;
+  const queue = useQueue(queueOptions);
+  const addRequest = (requestFn, addOptions = {}) => {
+    return queue.add(requestFn, {
+      ...addOptions,
+      metadata: {
+        ...addOptions.metadata,
+        type: "request"
+      }
+    });
+  };
+  const cancelByKey = (key) => {
+    const pending = queue.pendingTasks.value ?? [];
+    const running = queue.runningTasks.value ?? [];
+    const task = [...pending, ...running].find((t) => t.key === key);
+    if (task) {
+      queue.cancel(task.id);
+    }
+  };
+  return {
+    ...queue,
+    addRequest,
+    cancelByKey
+  };
+}

package/dist/useSSE.cjs

@@ -0,0 +1,241 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSSE = useSSE;
+var _vue = require("vue");
+function useSSE(options = {}) {
+  const {
+    parseJSON = true,
+    separator = "\n\n",
+    eventPrefix = "event:",
+    onStart,
+    onMessage,
+    onDone,
+    onError,
+    onCustomEvent,
+    ...fetchOptions
+  } = options;
+  const loading = (0, _vue.ref)(false);
+  const content = (0, _vue.ref)("");
+  const messages = (0, _vue.ref)([]);
+  const error = (0, _vue.shallowRef)(void 0);
+  let abortController = null;
+  let reader = null;
+  let decoder;
+  const getDecoder = () => {
+    if (!decoder) {
+      decoder = new TextDecoder();
+    }
+    return decoder;
+  };
+  const parseLine = line => {
+    const result = {
+      data: ""
+    };
+    if (!line || line.startsWith("#")) return result;
+    if (line.startsWith(eventPrefix)) {
+      result.event = line.slice(eventPrefix.length).trim();
+      return result;
+    }
+    if (line.startsWith("data:")) {
+      const data = line.slice(5);
+      result.data = data.startsWith(" ") ? data.slice(1) : data;
+    }
+    return result;
+  };
+  const parseSSE = rawData => {
+    const lines = rawData.split("\n");
+    let originalEventType = "message";
+    let eventData = "";
+    let done = false;
+    for (const line of lines) {
+      const {
+        event,
+        data
+      } = parseLine(line);
+      if (event) originalEventType = event;
+      if (data) eventData += data;
+    }
+    let eventType = "message";
+    switch (originalEventType.toLowerCase()) {
+      case "start":
+        eventType = "start";
+        break;
+      case "message":
+      case "chunk":
+      case "content":
+        eventType = "chunk";
+        break;
+      case "done":
+      case "stop":
+        eventType = "done";
+        done = true;
+        break;
+      case "error":
+        eventType = "error";
+        break;
+      case "tool":
+      case "function":
+        eventType = "tool";
+        break;
+      case "thinking":
+      case "thinking_start":
+      case "thinking_end":
+        eventType = "thinking";
+        break;
+      default:
+        eventType = "custom";
+        break;
+    }
+    if (!eventData && eventType !== "done" && eventType !== "start") return null;
+    let finalData = eventData;
+    if (parseJSON && eventData) {
+      try {
+        finalData = JSON.parse(eventData);
+      } catch {}
+    }
+    if (eventType === "custom" && onCustomEvent) {
+      onCustomEvent(originalEventType, finalData);
+    }
+    return {
+      event: eventType,
+      data: finalData,
+      raw: rawData,
+      done
+    };
+  };
+  const start = async requestOptions => {
+    stop();
+    reset();
+    const config = {
+      ...fetchOptions,
+      ...requestOptions
+    };
+    loading.value = true;
+    error.value = void 0;
+    onStart?.();
+    try {
+      let url = config.url || "";
+      if (config.baseURL) {
+        url = url.startsWith("http") ? url : config.baseURL + url;
+      }
+      if (config.params) {
+        const params = new URLSearchParams();
+        Object.entries(config.params).forEach(([key, value]) => {
+          if (Array.isArray(value)) {
+            value.forEach(v => params.append(key, String(v)));
+          } else {
+            params.append(key, String(value));
+          }
+        });
+        const sep = url.includes("?") ? "&" : "?";
+        url += sep + params.toString();
+      }
+      const headers = config.headers || {};
+      const fetchInit = {
+        method: config.method || "POST",
+        headers,
+        credentials: config.credentials || "same-origin"
+      };
+      if (config.data && config.method !== "GET") {
+        fetchInit.body = JSON.stringify(config.data);
+        if (!headers["Content-Type"]) {
+          headers["Content-Type"] = "application/json";
+        }
+      }
+      abortController = new AbortController();
+      fetchInit.signal = abortController.signal;
+      const response = await fetch(url, fetchInit);
+      if (!response.ok) {
+        throw new Error(`SSE request failed: ${response.status} ${response.statusText}`);
+      }
+      const body = response.body;
+      if (!body) {
+        throw new Error("Response body is null");
+      }
+      reader = body.getReader();
+      const textDecoder = getDecoder();
+      let buffer = "";
+      while (true) {
+        const {
+          done: readDone,
+          value
+        } = await reader.read();
+        if (readDone) {
+          if (buffer) {
+            const msg = parseSSE(buffer);
+            if (msg) {
+              handleMessage(msg);
+            }
+          }
+          break;
+        }
+        const chunk = textDecoder.decode(value, {
+          stream: true
+        });
+        buffer += chunk;
+        const parts = buffer.split(separator);
+        buffer = parts.pop() || "";
+        for (const part of parts) {
+          const msg = parseSSE(part);
+          if (msg) {
+            handleMessage(msg);
+            if (msg.done) {
+              onDone?.(content.value);
+              loading.value = false;
+              return;
+            }
+          }
+        }
+      }
+      onDone?.(content.value);
+    } catch (err) {
+      const errWithName = err;
+      if (errWithName?.name === "AbortError") {
+        return;
+      }
+      const errObj = err instanceof Error ? err : new Error(String(err));
+      error.value = errObj;
+      onError?.(errObj);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const handleMessage = message => {
+    if (typeof message.data === "string") {
+      content.value += message.data;
+    }
+    messages.value.push(message);
+    onMessage?.(message);
+  };
+  const stop = () => {
+    if (reader) {
+      reader.cancel();
+      reader = null;
+    }
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    loading.value = false;
+  };
+  const reset = () => {
+    content.value = "";
+    messages.value = [];
+    error.value = void 0;
+  };
+  (0, _vue.onUnmounted)(() => {
+    stop();
+  });
+  return {
+    loading,
+    content,
+    messages,
+    error,
+    start,
+    stop,
+    reset
+  };
+}