@blueking/chat-helper 0.0.4 → 0.0.5

package/README.md

@@ -357,10 +357,20 @@ useChatHelper({
       Authorization: `Bearer ${getToken()}`,
       'X-Request-ID': generateRequestId(),
     }),
+
+    // 也支持 Vue ref / computed（每次请求读取最新值）
+    // headers: computed(() => ({ Authorization: `Bearer ${token.value}` })),
+    // data: ref({ app_id: currentAppId.value }),
   },
 });
 ```
 
+**响应式写法说明**：
+
+- `headers` / `data` 支持：普通对象、零参函数、`ref`、`computed`，以及「函数返回 ref/computed」。
+- 每次发起 HTTP 请求前都会重新解析，修改 `.value` 或替换外层 ref 后，后续请求自动使用新值。
+- `data` 对 POST/PUT/PATCH/DELETE 合并进请求体；对 GET/HEAD/OPTIONS 合并进 query（`params`），不会写入 body。
+
 ### interceptors（可选）
 
 配置请求和响应拦截器，用于统一处理请求和响应。

package/dist/http/fetch/fetch.d.ts

@@ -1,3 +1,5 @@
+import type { MaybeRequestValue, RequestHeaders } from './resolve-request-value';
+export type { MaybeRequestValue, RequestData, RequestHeaders } from './resolve-request-value';
 export interface ApiResponse<T = unknown> {
     code: number | string;
     data: T;
@@ -8,10 +10,10 @@ export interface IRequestConfig {
     baseURL?: string;
     controller?: AbortController;
     credentials?: 'include' | 'omit' | 'same-origin';
-    /** 请求体；可传函数以便延迟求值（在 `prepareRequest` 中通过 `getValue` 解析） */
-    data?: (() => unknown) | unknown;
-    /** 请求头；可传函数以便延迟求值，便于动态注入（如 token） */
-    headers?: (() => Record<string, string>) | Record<string, string>;
+    /** 请求体；支持对象/函数/ref 延迟求值（在 `prepareRequest` 中解析） */
+    data?: MaybeRequestValue<unknown>;
+    /** 请求头；支持对象/函数/ref 延迟求值，便于动态注入（如 token） */
+    headers?: MaybeRequestValue<RequestHeaders>;
     method?: string;
     mode?: 'cors' | 'no-cors' | 'same-origin';
     params?: Record<string, unknown>;

package/dist/http/fetch/fetch.ts.js

@@ -22,8 +22,7 @@
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
- */ // API 标准响应格式
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+ */ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -104,6 +103,7 @@ function _object_spread_props(target, source) {
     }
     return target;
 }
+import { resolveRequestValue } from './resolve-request-value.ts.js';
 class InterceptorManager {
     clear() {
         this.handlers = [];
@@ -463,7 +463,7 @@ function createError(message, config, code, response) {
     return error;
 }
 function getValue(value) {
-    return typeof value === 'function' ? value() : value;
+    return resolveRequestValue(value);
 }
 /** 排除 AbortController、Headers 等类实例，只对普通对象深度合并 */ function isPlainObject(value) {
     if (!value || typeof value !== 'object') return false;

package/dist/http/fetch/index.d.ts

@@ -1,6 +1,9 @@
 import { FetchClient } from './fetch';
 import type { IUseChatHelperOptions } from '../../type';
+export { FetchClient } from './fetch';
 export type * from './fetch';
+export type { MaybeRequestValue, RequestData, RequestHeaders } from './resolve-request-value';
+export { resolveRequestValue } from './resolve-request-value';
 export declare const useFetch: (options: IUseChatHelperOptions) => {
     fetchClient: FetchClient;
     reset: (newOptions: IUseChatHelperOptions) => void;

package/dist/http/fetch/index.ts.js

@@ -75,23 +75,29 @@ function _object_spread_props(target, source) {
     return target;
 }
 import { FetchClient } from './fetch.ts.js';
-/** 仅支持 body 的 HTTP 方法 */ const BODY_METHODS = new Set([
+import { resolveRequestValue } from './resolve-request-value.ts.js';
+export { FetchClient } from './fetch.ts.js';
+export { resolveRequestValue } from './resolve-request-value.ts.js';
+/** 使用请求体的 HTTP 方法 */ const BODY_METHODS = new Set([
     'POST',
     'PUT',
     'PATCH',
     'DELETE'
 ]);
+/** 无请求体、通过 query 传参的 HTTP 方法 */ const QUERY_METHODS = new Set([
+    'GET',
+    'HEAD',
+    'OPTIONS'
+]);
 /** 排除 FormData / Blob / ArrayBuffer 等，只对普通对象展开合并 */ function isPlainObject(value) {
     if (!value || typeof value !== 'object') return false;
     const proto = Object.getPrototypeOf(value);
     return proto === Object.prototype || proto === null;
 }
-/** 解析「函数 | 值」两种形式，支持延迟求值（如响应式 token） */ function resolveValue(value) {
-    return typeof value === 'function' ? value() : value;
-}
 /**
  * 注册全局默认请求配置拦截器，将 `requestData.headers/data` 自动合并到每次请求。
- * - `headers` 注入所有请求；`data` 仅注入 POST/PUT/PATCH/DELETE，避免 GET/HEAD body 报错。
+ * - `headers` 注入所有请求
+ * - `data` 对 POST/PUT/PATCH/DELETE 合并进 body；对 GET/HEAD/OPTIONS 合并进 query（params）
  * - 优先级最低（单次 IRequestConfig > 用户拦截器 > 本拦截器）。
  */ function registerRequestDataInterceptor(client, opts) {
     const { headers: extraHeadersFn, data: extraDataFn } = opts.requestData;
@@ -99,10 +105,10 @@ import { FetchClient } from './fetch.ts.js';
     client.interceptors.request.use((config)=>{
         let result = config;
         if (extraHeadersFn) {
-            const extra = resolveValue(extraHeadersFn);
+            const extra = resolveRequestValue(extraHeadersFn);
             if (extra && Object.keys(extra).length > 0) {
-                var _resolveValue;
-                const existing = (_resolveValue = resolveValue(config.headers)) !== null && _resolveValue !== void 0 ? _resolveValue : {};
+                var _resolveRequestValue;
+                const existing = (_resolveRequestValue = resolveRequestValue(config.headers)) !== null && _resolveRequestValue !== void 0 ? _resolveRequestValue : {};
                 result = _object_spread_props(_object_spread({}, result), {
                     headers: _object_spread({}, existing, extra)
                 });
@@ -110,25 +116,34 @@ import { FetchClient } from './fetch.ts.js';
         }
         var _config_method;
         const method = ((_config_method = config.method) !== null && _config_method !== void 0 ? _config_method : 'GET').toUpperCase();
-        if (extraDataFn && BODY_METHODS.has(method)) {
-            const extra = resolveValue(extraDataFn);
+        if (extraDataFn) {
+            const extra = resolveRequestValue(extraDataFn);
             if (extra && Object.keys(extra).length > 0) {
-                const existing = resolveValue(config.data);
-                if (existing == null) {
-                    // body 为空（如 clearSession POST undefined）：直接用 extra 作为 body
+                if (BODY_METHODS.has(method)) {
+                    const existing = resolveRequestValue(config.data);
+                    if (existing == null) {
+                        // body 为空（如 clearSession POST undefined）：直接用 extra 作为 body
+                        result = _object_spread_props(_object_spread({}, result), {
+                            data: extra
+                        });
+                    } else if (isPlainObject(existing)) {
+                        // body 是普通对象：浅合并，extra 字段优先级更低（existing 已有同名字段时保留）
+                        result = _object_spread_props(_object_spread({}, result), {
+                            data: _object_spread({}, extra, existing)
+                        });
+                    } else {
+                        // body 是 FormData / Blob / string 等：跳过注入，避免破坏原始 body
+                        console.warn('[chat-helper] requestData.data 无法注入：当前请求体不是普通对象（FormData/Blob/string 等），已跳过合并。', {
+                            method,
+                            existingType: typeof existing
+                        });
+                    }
+                } else if (QUERY_METHODS.has(method)) {
+                    var _config_params;
+                    const existingParams = (_config_params = config.params) !== null && _config_params !== void 0 ? _config_params : {};
+                    // query 浅合并，extra 优先级更低（单次请求的 params 同名字段优先）
                     result = _object_spread_props(_object_spread({}, result), {
-                        data: extra
-                    });
-                } else if (isPlainObject(existing)) {
-                    // body 是普通对象：浅合并，extra 字段优先级更低（existing 已有同名字段时保留）
-                    result = _object_spread_props(_object_spread({}, result), {
-                        data: _object_spread({}, extra, existing)
-                    });
-                } else {
-                    // body 是 FormData / Blob / string 等：跳过注入，避免破坏原始 body
-                    console.warn('[chat-helper] requestData.data 无法注入：当前请求体不是普通对象（FormData/Blob/string 等），已跳过合并。', {
-                        method,
-                        existingType: typeof existing
+                        params: _object_spread({}, extra, existingParams)
                     });
                 }
             }

package/dist/http/fetch/resolve-request-value.d.ts

@@ -0,0 +1,16 @@
+/** 请求头键值对 */
+export type RequestHeaders = Record<string, string>;
+/** 请求体附加数据键值对 */
+export type RequestData = Record<string, unknown>;
+/**
+ * 支持延迟求值的请求配置值：
+ * - 普通对象
+ * - 零参函数（可返回对象、ref、computed）
+ * - Ref / ComputedRef / MaybeRef
+ */
+export type MaybeRequestValue<T> = T | (() => MaybeRequestValue<T>);
+/**
+ * 解析请求配置值，在每次请求前调用以读取最新值。
+ * 递归展开函数、ref、computed，直到得到最终对象或原始值。
+ */
+export declare function resolveRequestValue<T>(value: MaybeRequestValue<T> | undefined): T | undefined;

package/dist/http/fetch/resolve-request-value.ts.js

@@ -0,0 +1,38 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ */ import { isRef, unref } from 'vue';
+function isVueRef(value) {
+    return isRef(value);
+}
+/**
+ * 解析请求配置值，在每次请求前调用以读取最新值。
+ * 递归展开函数、ref、computed，直到得到最终对象或原始值。
+ */ export function resolveRequestValue(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    let current = value;
+    const maxDepth = 32;
+    let depth = 0;
+    while(depth < maxDepth){
+        depth += 1;
+        if (typeof current === 'function') {
+            current = current();
+            continue;
+        }
+        if (isVueRef(current)) {
+            current = unref(current);
+            continue;
+        }
+        break;
+    }
+    if (depth >= maxDepth) {
+        console.warn('[chat-helper] resolveRequestValue: exceeded max unwrap depth');
+    }
+    return current;
+}

package/dist/type.d.ts

@@ -1,5 +1,7 @@
 import type { IRequestConfig, ISSEProtocol } from './http/fetch';
 import type { IResponse } from './http/fetch';
+import type { MaybeRequestValue, RequestData, RequestHeaders } from './http/fetch/resolve-request-value';
+export type { MaybeRequestValue, RequestData, RequestHeaders } from './http/fetch/resolve-request-value';
 export interface IUseChatHelperOptions {
     protocol?: ISSEProtocol;
     /** 自定义拦截器，优先级高于内置 requestData 拦截器 */
@@ -7,10 +9,10 @@ export interface IUseChatHelperOptions {
         request?: (config: IRequestConfig) => IRequestConfig;
         response?: (response: IResponse) => IResponse;
     };
-    /** 全局默认请求配置，通过内置拦截器自动合并到每次请求（函数形式可延迟求值） */
+    /** 全局默认请求配置，通过内置拦截器自动合并到每次请求（支持对象/函数/ref 延迟求值） */
     requestData: {
-        data?: (() => Record<string, unknown>) | Record<string, unknown>;
-        headers?: (() => Record<string, string>) | Record<string, string>;
+        data?: MaybeRequestValue<RequestData>;
+        headers?: MaybeRequestValue<RequestHeaders>;
         urlPrefix: string;
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueking/chat-helper",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "",
   "main": "./dist/index.ts.js",
   "types": "./dist/index.d.ts",