@yh-ui/request 0.1.21

package/dist/request.mjs

@@ -0,0 +1,339 @@
+let requestIdCounter = 0;
+export function generateRequestId() {
+  return `req_${Date.now()}_${++requestIdCounter}`;
+}
+export function serializeParams(params) {
+  const searchParams = new URLSearchParams();
+  const encode = (value) => {
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  };
+  const addParam = (key, value) => {
+    if (value !== null && value !== void 0) {
+      searchParams.append(key, encode(value));
+    }
+  };
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => addParam(key, v));
+    } else {
+      addParam(key, value);
+    }
+  }
+  return searchParams.toString();
+}
+export function buildURL(options) {
+  const { baseURL = "", url = "", params, serializeParams: sp = true } = options;
+  let fullPath = url;
+  if (baseURL) {
+    fullPath = url.startsWith("http") ? url : baseURL + url;
+  }
+  if (params && Object.keys(params).length > 0 && sp) {
+    const queryString = serializeParams(params);
+    const separator = fullPath.includes("?") ? "&" : "?";
+    fullPath += separator + queryString;
+  }
+  return fullPath;
+}
+export function createRequestError(error, config, response) {
+  const err = typeof error === "string" ? new Error(error) : error;
+  const requestError = {
+    name: err.name,
+    message: err.message,
+    config,
+    response,
+    requestId: config?.requestId
+  };
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    requestError.isNetworkError = true;
+    requestError.code = "NETWORK_ERROR";
+  } else if (config?.signal?.aborted) {
+    requestError.isCanceled = true;
+    requestError.code = "CANCELED";
+  } else if (response) {
+    requestError.code = `HTTP_${response.status}`;
+  }
+  return requestError;
+}
+export class InterceptorManagerImpl {
+  handlers = [];
+  use(onFulfilled, onRejected) {
+    this.handlers.push({ fulfilled: onFulfilled, rejected: onRejected });
+    return this.handlers.length - 1;
+  }
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+  clear() {
+    this.handlers = [];
+  }
+  async execute(value) {
+    let result = value;
+    for (const handler of this.handlers) {
+      if (handler) {
+        try {
+          result = await handler.fulfilled(result);
+        } catch (error) {
+          if (handler.rejected) {
+            result = await handler.rejected(error);
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+    return result;
+  }
+}
+export class Request {
+  defaults;
+  interceptors;
+  abortControllers = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.defaults = {
+      timeout: 3e4,
+      credentials: "same-origin",
+      responseType: "json",
+      serializeParams: true,
+      retry: false,
+      retryTimes: 3,
+      retryDelay: 1e3,
+      retryCondition: (error) => {
+        return error.isNetworkError || (error.response?.status ?? 0) >= 500;
+      },
+      ...options.defaultOptions
+    };
+    this.interceptors = {
+      request: new InterceptorManagerImpl(),
+      response: new InterceptorManagerImpl()
+    };
+  }
+  /**
+   * 创建请求实例的静态方法
+   */
+  static create(options) {
+    return new Request(options);
+  }
+  /**
+   * 生成 AbortSignal
+   */
+  createAbortSignal(options) {
+    const controller = new AbortController();
+    if (options.requestKey) {
+      const prevController = this.abortControllers.get(options.requestKey);
+      if (prevController) {
+        prevController.abort();
+      }
+      this.abortControllers.set(options.requestKey, controller);
+    }
+    if (options.timeout) {
+      const timeoutId = setTimeout(() => {
+        controller.abort(new Error("Request timeout"));
+      }, options.timeout);
+      controller.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+      });
+    }
+    return controller.signal;
+  }
+  /**
+   * 执行请求
+   */
+  async request(options) {
+    const requestId = generateRequestId();
+    const mergedOptions = {
+      ...this.defaults,
+      ...options,
+      requestId
+    };
+    mergedOptions.fullPath = buildURL(mergedOptions);
+    mergedOptions.signal = this.createAbortSignal(mergedOptions);
+    let config = await this.interceptors.request.execute(mergedOptions);
+    if (config.requestInterceptor) {
+      config = await config.requestInterceptor(config);
+    }
+    const executeRequest = async () => {
+      try {
+        const fetchOptions = {
+          method: config.method || "GET",
+          headers: config.headers,
+          credentials: config.credentials,
+          signal: config.signal
+        };
+        if (config.data !== void 0 && config.method !== "GET") {
+          if (config.responseType === "formdata" || config.data instanceof FormData) {
+            fetchOptions.body = config.data;
+          } else {
+            fetchOptions.body = JSON.stringify(config.data);
+            if (!fetchOptions.headers) {
+              fetchOptions.headers = {};
+            }
+            const headers = fetchOptions.headers;
+            if (!headers["Content-Type"]) {
+              headers["Content-Type"] = "application/json";
+            }
+          }
+        }
+        let response;
+        try {
+          response = await fetch(config.fullPath, fetchOptions);
+        } catch (error) {
+          throw createRequestError(error, config);
+        }
+        if (!response.ok) {
+          const error = createRequestError(
+            `Request failed with status ${response.status}`,
+            config,
+            response
+          );
+          try {
+            await this.interceptors.response.execute({
+              data: void 0,
+              response,
+              config,
+              requestId
+            });
+          } catch {
+          }
+          throw error;
+        }
+        let data;
+        if (config.rawResponse) {
+          data = response;
+        } else {
+          switch (config.responseType) {
+            case "text":
+              data = await response.text();
+              break;
+            case "blob":
+              data = await response.blob();
+              break;
+            case "arraybuffer":
+              data = await response.arrayBuffer();
+              break;
+            case "formdata":
+              data = await response.formData();
+              break;
+            case "json":
+            default:
+              const text = await response.text();
+              data = text ? JSON.parse(text) : null;
+              break;
+          }
+        }
+        const requestResponse = {
+          data,
+          response,
+          config,
+          requestId
+        };
+        const finalResponse = await this.interceptors.response.execute(
+          requestResponse
+        );
+        return finalResponse;
+      } catch (error) {
+        const requestError = error;
+        const currentRetryCount = config._retryCount ?? 0;
+        const maxRetries = config.retryTimes ?? 3;
+        const shouldRetry = config.retry && currentRetryCount < maxRetries && (!config.retryCondition || config.retryCondition(requestError));
+        if (shouldRetry) {
+          const baseDelay = config.retryDelay || 1e3;
+          const delayCalculator = config.retryDelayCalculator || defaultExponentialBackoff;
+          const delay = delayCalculator(currentRetryCount, baseDelay);
+          if (delay < 0) {
+            if (config.errorHandler) {
+              config.errorHandler(requestError);
+            }
+            throw requestError;
+          }
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          config._retryCount = currentRetryCount + 1;
+          return executeRequest();
+        }
+        if (config.errorHandler) {
+          config.errorHandler(requestError);
+        }
+        throw requestError;
+      }
+    };
+    return executeRequest();
+  }
+  /**
+   * 便捷方法
+   */
+  get(url, options) {
+    return this.request({ ...options, url, method: "GET" });
+  }
+  post(url, data, options) {
+    return this.request({ ...options, url, method: "POST", data });
+  }
+  put(url, data, options) {
+    return this.request({ ...options, url, method: "PUT", data });
+  }
+  delete(url, options) {
+    return this.request({ ...options, url, method: "DELETE" });
+  }
+  patch(url, data, options) {
+    return this.request({ ...options, url, method: "PATCH", data });
+  }
+  head(url, options) {
+    return this.request({ ...options, url, method: "HEAD" });
+  }
+  options(url, options) {
+    return this.request({ ...options, url, method: "OPTIONS" });
+  }
+  /**
+   * 设置默认配置
+   */
+  setConfig(config) {
+    this.defaults = { ...this.defaults, ...config };
+  }
+  /**
+   * 获取默认配置
+   */
+  getConfig() {
+    return { ...this.defaults };
+  }
+  /**
+   * 取消所有请求
+   */
+  cancelAll() {
+    this.abortControllers.forEach((controller) => {
+      controller.abort();
+    });
+    this.abortControllers.clear();
+  }
+  /**
+   * 取消指定 key 的请求
+   */
+  cancel(key) {
+    const controller = this.abortControllers.get(key);
+    if (controller) {
+      controller.abort();
+      this.abortControllers.delete(key);
+    }
+  }
+}
+export function defaultExponentialBackoff(retryCount, defaultDelay = 1e3) {
+  const baseDelay = defaultDelay * Math.pow(2, retryCount);
+  const jitter = Math.random() * 1e3;
+  return Math.min(baseDelay + jitter, 3e4);
+}
+export function linearBackoff(retryCount, defaultDelay) {
+  return defaultDelay * (retryCount + 1);
+}
+export function fixedBackoff(_retryCount, defaultDelay) {
+  return defaultDelay;
+}
+export function exponentialBackoffWithMaxRetries(retryCount, defaultDelay, maxRetries = 10) {
+  if (retryCount >= maxRetries) {
+    return -1;
+  }
+  return defaultExponentialBackoff(retryCount, defaultDelay);
+}
+export const request = new Request();
+export const createRequest = (options) => new Request(options);
+export default request;

package/dist/types.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildPath = buildPath;
+function buildPath(path, params) {
+  let result = path;
+  for (const [key, value] of Object.entries(params)) {
+    result = result.replace(`:${key}`, encodeURIComponent(String(value)));
+  }
+  return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @yh-ui/request 严格类型定义
+ * 杜绝 any，全链路类型安全
+ */
+/** HTTP 方法 */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+/** 响应数据类型 */
+export type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer' | 'formdata';
+/** 可序列化的查询参数值 */
+export type ParamValue = string | number | boolean | string[] | number[];
+/** 查询参数对象 */
+export type ParamsRecord = Record<string, ParamValue>;
+/** 请求体类型约束 */
+export type RequestBody = Record<string, unknown> | FormData | Blob | ArrayBuffer | string | null;
+/** 重试延迟计算器类型 */
+export type RetryDelayCalculator = (retryCount: number, defaultDelay: number) => number;
+/**
+ * 从 URL 路径中提取路径参数
+ * @example
+ * type Params = PathParams<'/api/users/:id'>
+ * // => { id: string }
+ */
+export type PathParams<T extends string> = T extends `${infer _}:${infer Param}/${infer Rest}` ? Param extends string ? {
+    [K in Param]: string;
+} & PathParams<Rest> : never : T extends `${infer _}:${infer Param}` ? {
+    [K in Param]: string;
+} : Record<string, never>;
+/**
+ * 构建带路径参数的 URL
+ * @example
+ * const url = buildPath('/api/users/:id', { id: '123' })
+ * // => '/api/users/123'
+ */
+export declare function buildPath<T extends string>(path: T, params: PathParams<T>): string;
+export interface RequestOptions<TRequest = unknown> {
+    /** 请求基础 URL */
+    baseURL?: string;
+    /** 请求路径 */
+    url?: string;
+    /** 请求方法 */
+    method?: HttpMethod;
+    /** URL 查询参数 */
+    params?: ParamsRecord;
+    /** 请求体数据 */
+    data?: TRequest;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 请求超时时间 (ms) */
+    timeout?: number;
+    /** credentials 模式 */
+    credentials?: RequestCredentials;
+    /** 响应类型 */
+    responseType?: ResponseType;
+    /** 是否 retry */
+    retry?: boolean;
+    /** 重试次数 */
+    retryTimes?: number;
+    /** 重试延迟 (ms) */
+    retryDelay?: number;
+    /** 重试条件函数 */
+    retryCondition?: (error: RequestError) => boolean;
+    /** 重试延迟计算器 */
+    retryDelayCalculator?: RetryDelayCalculator;
+    /** 请求拦截器 */
+    requestInterceptor?: (config: InternalRequestOptions) => InternalRequestOptions | Promise<InternalRequestOptions>;
+    /** 响应拦截器 */
+    responseInterceptor?: <T>(response: RequestResponse<T>) => RequestResponse<T> | Promise<RequestResponse<T>>;
+    /** 错误处理函数 */
+    errorHandler?: (error: RequestError) => void;
+    /** 是否返回原始响应 */
+    rawResponse?: boolean;
+    /** 是否自动序列化 params */
+    serializeParams?: boolean;
+    /** 是否 abort 上一个相同 key 的请求 */
+    abortSameKey?: boolean;
+    /** 请求唯一标识 key（用于去重） */
+    requestKey?: string;
+    /** 调试模式 */
+    debug?: boolean;
+    /** 回退数据（请求失败时返回） */
+    fallbackData?: unknown;
+    /** AbortSignal */
+    signal?: AbortSignal;
+}
+export interface InternalRequestOptions<TRequest = unknown> extends RequestOptions<TRequest> {
+    /** 完整的请求 URL */
+    fullPath?: string;
+    /** AbortSignal */
+    signal?: AbortSignal;
+    /** 请求 ID */
+    requestId?: string;
+}
+export interface RequestResponse<T = unknown> {
+    /** 响应数据 */
+    data: T;
+    /** 原始响应 */
+    response: Response;
+    /** 请求配置 */
+    config: InternalRequestOptions;
+    /** 请求 ID */
+    requestId: string;
+    /** 请求耗时 (ms) */
+    duration?: number;
+}
+export interface RequestError extends Error {
+    message: string;
+    name: string;
+    code?: string;
+    originalError?: Error;
+    config?: InternalRequestOptions;
+    response?: Response;
+    isTimeout?: boolean;
+    isNetworkError?: boolean;
+    isCanceled?: boolean;
+    requestId?: string;
+}
+export interface InterceptorManager<T> {
+    use(onFulfilled: (value: T) => T | Promise<T>, onRejected?: (error: RequestError) => T | Promise<T>): number;
+    eject(id: number): void;
+    clear(): void;
+    execute(value: T): Promise<T>;
+}
+/** HTTP 适配器接口 - 支持多运行时 */
+export interface HttpAdapter {
+    /** 适配器名称 */
+    name: string;
+    /** 发送请求 */
+    request<T>(config: InternalRequestOptions): Promise<RequestResponse<T>>;
+    /** 是否支持当前环境 */
+    isSupported(): boolean;
+}
+export interface RequestInstance {
+    request<TResponse = unknown, TRequest = unknown>(options: RequestOptions<TRequest> & {
+        url: string;
+    }): Promise<RequestResponse<TResponse>>;
+    get<T = unknown>(url: string, options?: Omit<RequestOptions, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    post<T = unknown, D = unknown>(url: string, data?: D, options?: Omit<RequestOptions<D>, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    put<T = unknown, D = unknown>(url: string, data?: D, options?: Omit<RequestOptions<D>, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    delete<T = unknown>(url: string, options?: Omit<RequestOptions, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    patch<T = unknown, D = unknown>(url: string, data?: D, options?: Omit<RequestOptions<D>, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    head<T = unknown>(url: string, options?: Omit<RequestOptions, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    options<T = unknown>(url: string, options?: Omit<RequestOptions, 'method' | 'data'>): Promise<RequestResponse<T>>;
+    setConfig(config: Partial<RequestOptions>): void;
+    getConfig(): RequestOptions;
+    interceptors: {
+        request: InterceptorManager<InternalRequestOptions>;
+        response: InterceptorManager<RequestResponse<unknown>>;
+    };
+    cancelAll(): void;
+    cancel(key: string): void;
+}
+export interface CreateRequestOptions extends Partial<RequestOptions> {
+    defaultOptions?: Partial<RequestOptions>;
+    instanceId?: string;
+    /** 自定义适配器 */
+    adapter?: HttpAdapter;
+}

package/dist/types.mjs

@@ -0,0 +1,7 @@
+export function buildPath(path, params) {
+  let result = path;
+  for (const [key, value] of Object.entries(params)) {
+    result = result.replace(`:${key}`, encodeURIComponent(String(value)));
+  }
+  return result;
+}

package/dist/useAIStream.cjs

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAIStream = useAIStream;
+var _vue = require("vue");
+var _useSSE = require("./useSSE.cjs");
+function useAIStream(options = {}) {
+  const {
+    parseAIMessage = true,
+    appendMode = true,
+    onText,
+    onThinking,
+    onToolCall,
+    onMessage: userOnMessage,
+    ...sseOptions
+  } = options;
+  const text = (0, _vue.ref)("");
+  const thinking = (0, _vue.ref)("");
+  const toolCalls = (0, _vue.ref)([]);
+  const done = (0, _vue.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
+  } = (0, _useSSE.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
+  };
+}