hifun-tools 1.2.11 → 1.3.1

package/dist/init/ende.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AES加密
+ * @param {string} text - 要加密的原文
+ * @param {string} [keyStr] - 密钥（长度16/24/32字节）
+ * @returns {string} 加密后的Base64字符串
+ */
+export declare function AesEncrypt(text: string, keyStr?: string): any;
+/**
+ * AES解密
+ * @param {string} cipherText - 要解密的Base64密文
+ * @param {string} [keyStr] - 密钥（必须与加密时一致）
+ * @returns {string} 解密后的明文
+ */
+export declare function AesDecrypt(cipherText: any, keyStr?: string): any;

package/dist/init/ende.js

@@ -0,0 +1,38 @@
+// 通用 AES 加解密工具
+// 支持 TS / ESM / CJS / 浏览器
+import CryptoJS from "crypto-js";
+/**
+ * AES加密
+ * @param {string} text - 要加密的原文
+ * @param {string} [keyStr] - 密钥（长度16/24/32字节）
+ * @returns {string} 加密后的Base64字符串
+ */
+export function AesEncrypt(text, keyStr = "1234567890abcdef") {
+    const key = CryptoJS.enc.Utf8.parse(keyStr);
+    const encrypted = CryptoJS.AES.encrypt(text, key, {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return encrypted.toString();
+}
+/**
+ * AES解密
+ * @param {string} cipherText - 要解密的Base64密文
+ * @param {string} [keyStr] - 密钥（必须与加密时一致）
+ * @returns {string} 解密后的明文
+ */
+export function AesDecrypt(cipherText, keyStr = "1234567890abcdef") {
+    const key = CryptoJS.enc.Utf8.parse(keyStr);
+    const decrypted = CryptoJS.AES.decrypt(cipherText, key, {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return CryptoJS.enc.Utf8.stringify(decrypted);
+}
+/**
+ * 全局挂载（浏览器端）
+ */
+if (typeof window !== "undefined") {
+    window.Aesen = AesEncrypt;
+    window.Aesde = AesDecrypt;
+}

package/dist/init/index.d.ts

@@ -1,6 +1,3 @@
-interface InitConfig {
-    fileType: ("lineAddress" | "lineTenants")[];
-}
 type TenantConfig = {
     PUBLIC_TITLE: string;
     SITE_TITLE: string;
@@ -22,7 +19,9 @@ declare class InitCls {
     private getTenantInfoStrictSync;
     /** 严格初始化（必须在应用启动时调用） */
     private initialize;
-    InitConfig({ fileType }: InitConfig): void;
+    InitConfig({ fileType }: {
+        fileType: string[];
+    }): Promise<any[]>;
     private LoadGatewayConfig;
 }
 declare const HF: InitCls;

package/dist/init/index.js

@@ -1,5 +1,6 @@
 import { getResource } from "./getResource";
 import { getOptimalDecodedString } from "./utils";
+import { AesDecrypt } from "./ende";
 class InitCls {
     domainBaseUrl = "";
     tenantConfig = null;
@@ -14,97 +15,99 @@ class InitCls {
     /** 获取配置 */
     getTenantConfig() {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败");
+            throw new Error("租户尚未初始化或初始化失败getTenantConfig");
         }
         return this.tenantConfig;
     }
     /** 获取租户名 */
     getTenant() {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败");
+            throw new Error("租户尚未初始化或初始化失败getTenant");
         }
         return this.tenant;
     }
     getImgPath(imgName) {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败");
+            throw new Error("租户尚未初始化或初始化失败getImgPath");
         }
         return getResource(`${this.tenant}/image/${imgName}`);
     }
     /** 严格同步获取租户信息 */
-    getTenantInfoStrictSync() {
-        const xhr = new XMLHttpRequest();
-        xhr.open("GET", "/lineTenants.txt?t=" + Date.now(), false);
-        xhr.send(null);
-        if (xhr.status === 200) {
-            try {
-                const rawData = atob(xhr.responseText);
-                const data = JSON.parse(rawData);
-                const host = location.host;
-                const matchedEntry = Object.entries(data).find(([key]) => {
-                    // key 是明文主机地址，直接比较即可
-                    // 兼容 www 前缀的情况
-                    // 如果当前 host 有 www 前缀，则也匹配无 www 前缀的配置
-                    // 如果当前 host 无 www 前缀，则也匹配有 www 前缀的配置
-                    return (key === host ||
-                        (host.startsWith("www.") && key === host.substring(4)) ||
-                        (!host.startsWith("www.") && key === "www." + host));
-                });
-                if (matchedEntry) {
-                    const matched = matchedEntry[1];
-                    if (data && matched) {
-                        console.info(`🏠 匹配租户: ${matched}`);
-                        return { tenant: matched };
-                    }
-                }
+    async getTenantInfoStrictSync() {
+        try {
+            const response = await fetch(`/lineTenants.txt?t=${Date.now()}`, {
+                method: "GET",
+                cache: "no-store",
+            });
+            console.log(response);
+            if (!response.ok) {
+                throw new Error(`HTTP 状态码错误: ${response.status}`);
             }
-            catch (error) {
-                console.error("解析 lineTenants.txt 失败:", error);
-                if (location.host.includes("iggame") ||
-                    location.host.includes("localhost")) {
-                    console.info(`🏠 iggame匹配到默认租户`);
-                    return {
-                        tenant: "iggame",
-                    };
+            const rawText = await response.text();
+            const rawData = AesDecrypt(rawText);
+            const data = JSON.parse(rawData);
+            const host = location.host;
+            const matchedEntry = Object.entries(data).find(([key]) => {
+                return (key === host ||
+                    (host.startsWith("www.") && key === host.substring(4)) ||
+                    (!host.startsWith("www.") && key === "www." + host));
+            });
+            if (matchedEntry) {
+                const matched = matchedEntry[1];
+                if (data && matched) {
+                    console.info(`🏠 匹配租户: ${matched}`);
+                    return { tenant: matched };
                 }
-                throw new Error("lineTenants.txt 格式错误");
             }
+            // 默认租户匹配
+            if (host.includes("iggame") || host.includes("localhost")) {
+                console.info(`🏠 iggame匹配到默认租户`);
+                return { tenant: "iggame" };
+            }
+            throw new Error("未找到匹配租户");
         }
-        if (location.host.includes("iggame") ||
-            location.host.includes("localhost")) {
-            console.info(`🏠 iggame匹配到默认租户`);
-            return {
-                tenant: "iggame",
-            };
+        catch (error) {
+            console.error("解析 lineTenants.txt 失败:", error);
+            const host = location.host;
+            if (host.includes("iggame") || host.includes("localhost")) {
+                console.info(`🏠 iggame匹配到默认租户`);
+                return { tenant: "iggame" };
+            }
+            throw new Error("无法获取有效的租户信息");
         }
-        throw new Error("无法获取有效的租户信息");
     }
     /** 严格初始化（必须在应用启动时调用） */
-    initialize() {
+    async initialize() {
         if (this.initialized)
-            return;
+            return this.tenant;
         try {
-            const tenantInfo = this.getTenantInfoStrictSync();
+            const tenantInfo = await this.getTenantInfoStrictSync();
             this.tenant = tenantInfo.tenant;
             this.tenantConfig = getResource(`${tenantInfo.tenant}/config.json`);
             this.initialized = true;
             console.info(`🏢 严格加载租户成功: ${this.tenant}`, this.getImgPath("logo-default.png"));
+            return this.tenant;
         }
         catch (error) {
             console.error("严格租户加载失败:", error);
             throw error;
         }
     }
-    InitConfig({ fileType }) {
+    async InitConfig({ fileType }) {
         console.log("加载类型:", fileType);
+        const tasks = [];
         if (fileType.includes("lineAddress")) {
             console.log("初始化 lineAddress...");
-            this.LoadGatewayConfig();
+            tasks.push(this.LoadGatewayConfig());
         }
         if (fileType.includes("lineTenants")) {
             console.log("初始化 lineTenants...");
-            this.initialize();
+            tasks.push(this.initialize());
         }
+        // 等待所有异步任务完成
+        const results = await Promise.all(tasks);
+        console.log("所有初始化完成:", results);
+        return results;
     }
     async LoadGatewayConfig() {
         if (this.domainBaseUrl)
@@ -112,8 +115,7 @@ class InitCls {
         try {
             const response = await fetch(`/lineAddress.txt?t=${Date.now()}`);
             const configText = await response.text();
-            const baseUrl = JSON.parse(atob(configText));
-            console.log("baseUrlbaseUrl", baseUrl);
+            const baseUrl = JSON.parse(AesDecrypt(configText));
             if (Array.isArray(baseUrl)) {
                 try {
                     this.domainBaseUrl = await getOptimalDecodedString(baseUrl);

package/dist/request/index.d.ts

@@ -1,2 +1,174 @@
-/** 通用 HTTP 请求封装 */
-export declare function HttpServer<T = any>(endpoint: string, params?: Record<string, any>, method?: "GET" | "POST" | "PUT" | "DELETE"): Promise<T>;
+/**
+ * 错误类型区分
+ */
+export declare class HttpNetworkError extends Error {
+    code: number;
+    detail?: any;
+    constructor(message?: string, detail?: any);
+}
+export declare class HttpTimeoutError extends Error {
+    code: number;
+    detail?: any;
+    constructor(message?: string, detail?: any);
+}
+export declare class HttpBusinessError extends Error {
+    code: number;
+    data?: any;
+    constructor(code: number, message?: string, data?: any);
+}
+/**
+ * 通用响应结构（按后端常见 { code, msg, data }）
+ */
+export interface HttpResponseWrapper<T = any> {
+    code: number;
+    msg: string;
+    data: T;
+}
+/**
+ * 最终返回结构（包装）
+ */
+export interface HttpResult<T = any> {
+    code: number;
+    msg: string;
+    data: T | null;
+    raw?: any;
+}
+/**
+ * 请求可选参数（中文注释会显示在编辑器提示中）
+ */
+export interface HttpOptions {
+    /**
+     * 重试次数（网络错误 / 超时 时会触发重试）
+     * @default 3
+     */
+    retry?: number;
+    /**
+     * 重试间隔（毫秒）
+     * @default 1000
+     */
+    retryDelay?: number;
+    /**
+     * 单次请求超时时间（毫秒），超时会触发 AbortController
+     * @default 8000
+     */
+    timeout?: number;
+    /**
+     * 是否以 FormData 方式发送（用于文件上传）
+     * @default false
+     */
+    isFormData?: boolean;
+    /**
+     * 是否返回完整 wrapper（包含 code/msg/data），true 返回 wrapper；false 默认直接返回 data（如果后端约定 data 包裹）
+     * @default false
+     */
+    unwrap?: boolean;
+    /**
+     * 额外请求头（会和默认 headers 合并）
+     */
+    headers?: Record<string, string>;
+    /**
+     * 是否开启调试日志（会打印请求/响应信息）
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * GET 缓存（仅对 GET 生效）
+     * - 若为 true：使用默认 TTL
+     * - 若为数字：表示 TTL 毫秒
+     * - 默认不缓存
+     */
+    cache?: boolean | number;
+    /**
+     * 期望的响应类型（json/text/blob）
+     * @default "json"
+     */
+    responseType?: "json" | "text" | "blob";
+}
+/**
+ * 请求拦截器签名：可以同步或异步修改请求参数/headers
+ */
+export type RequestInterceptor = (ctx: {
+    url: string;
+    method: string;
+    params: Record<string, any>;
+    headers: Record<string, string>;
+    options: HttpOptions;
+}) => Promise<void> | void;
+/**
+ * 响应拦截器签名：可以处理 response wrapper 或者抛错
+ */
+export type ResponseInterceptor = <T = any>(ctx: {
+    url: string;
+    method: string;
+    params: Record<string, any>;
+    headers: Record<string, string>;
+    options: HttpOptions;
+    response: HttpResponseWrapper<T>;
+}) => Promise<void> | void;
+/**
+ * 错误拦截器签名
+ */
+export type ErrorInterceptor = (err: any) => Promise<void> | void;
+/**
+ * 全局配置
+ */
+export interface HttpClientConfig {
+    /**
+     * 默认 retry 次数
+     */
+    defaultRetry?: number;
+    /**
+     * 默认 retry delay（ms）
+     */
+    defaultRetryDelay?: number;
+    /**
+     * 默认 timeout（ms）
+     */
+    defaultTimeout?: number;
+    /**
+     * 默认缓存 TTL（ms）
+     */
+    defaultCacheTTL?: number;
+    /**
+     * 签名函数（可替换为 HMAC/RSA）
+     * - 接收 (udid, timestamp) 返回 sign string
+     */
+    signFn?: (udid: string, timestamp: number) => string;
+    /**
+     * paySign 函数（可选）
+     */
+    paySignFn?: (udid: string, timestamp: number) => string;
+    /**
+     * 全局请求拦截器数组（按顺序执行）
+     */
+    requestInterceptors?: RequestInterceptor[];
+    /**
+     * 全局响应拦截器数组（按顺序执行）
+     */
+    responseInterceptors?: ResponseInterceptor[];
+    /**
+     * 全局错误拦截器数组（按顺序执行）
+     */
+    errorInterceptors?: ErrorInterceptor[];
+    /**
+     * 是否默认打印请求日志
+     */
+    debug?: boolean;
+}
+/** 导出用于设置全局配置的 API（在 app 启动处调用） */
+export declare function setHttpClientConfig(cfg: Partial<HttpClientConfig>): void;
+/** 导出注册拦截器方便使用 */
+export declare function useRequestInterceptor(fn: RequestInterceptor): void;
+export declare function useResponseInterceptor(fn: ResponseInterceptor): void;
+export declare function useErrorInterceptor(fn: ErrorInterceptor): void;
+/** 生成或获取 UDID */
+export declare function generateUdid(): Promise<string>;
+/**
+ * 核心请求函数
+ * @param endpoint 接口路径（相对或绝对）
+ * @param params GET 的 query 或 POST 的 body（如果需要同时指定 query/body，请将参数组织为 { query: {...}, body: {...} }）
+ * @param method HTTP 方法
+ * @param options 可选项（超时、重试、缓存等）
+ * @returns Promise<HttpResult<T>> （默认 unwrap=false 会返回完整 wrapper。unwrap=true 则返回 data 内容）
+ */
+export declare function HttpServer<T = any>(endpoint: string, params?: Record<string, any>, method?: "GET" | "POST" | "PUT" | "DELETE", options?: HttpOptions): Promise<HttpResult<T> | T>;

package/dist/request/index.js

@@ -1,17 +1,115 @@
+// httpClient.ts
 import md5 from "md5";
 import { Local, getParams, isMobile } from "../utils/index";
 import { HF } from "../init";
-/** 生成随机 UDID */
-function generateUdid() {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    return Array.from({ length: 32 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join("");
+/**
+ * 错误类型区分
+ */
+export class HttpNetworkError extends Error {
+    code = -1;
+    detail;
+    constructor(message = "Network error", detail) {
+        super(message);
+        this.name = "HttpNetworkError";
+        this.detail = detail;
+    }
+}
+export class HttpTimeoutError extends Error {
+    code = -2;
+    detail;
+    constructor(message = "Request timeout", detail) {
+        super(message);
+        this.name = "HttpTimeoutError";
+        this.detail = detail;
+    }
+}
+export class HttpBusinessError extends Error {
+    code;
+    data;
+    constructor(code, message = "Business error", data) {
+        super(message);
+        this.name = "HttpBusinessError";
+        this.code = code;
+        this.data = data;
+    }
+}
+/** 默认配置值 */
+const DEFAULTS = {
+    defaultRetry: 3,
+    defaultRetryDelay: 1000,
+    defaultTimeout: 8000,
+    defaultCacheTTL: 60 * 1000, // 1 minute
+};
+/** 可变全局配置实例 */
+const globalConfig = {
+    defaultRetry: DEFAULTS.defaultRetry,
+    defaultRetryDelay: DEFAULTS.defaultRetryDelay,
+    defaultTimeout: DEFAULTS.defaultTimeout,
+    defaultCacheTTL: DEFAULTS.defaultCacheTTL,
+    signFn: (udid, ts) => md5(udid + "jgyh,kasd" + ts),
+    paySignFn: (udid, ts) => md5(udid.substring(0, 6) + "8qiezi" + ts),
+    requestInterceptors: [],
+    responseInterceptors: [],
+    errorInterceptors: [],
+    debug: false,
+};
+/** 导出用于设置全局配置的 API（在 app 启动处调用） */
+export function setHttpClientConfig(cfg) {
+    Object.assign(globalConfig, cfg);
+}
+/** 导出注册拦截器方便使用 */
+export function useRequestInterceptor(fn) {
+    globalConfig.requestInterceptors.push(fn);
+}
+export function useResponseInterceptor(fn) {
+    globalConfig.responseInterceptors.push(fn);
+}
+export function useErrorInterceptor(fn) {
+    globalConfig.errorInterceptors.push(fn);
 }
-/** 获取或生成 Finger（UDID） */
-async function getFinger() {
+/** 缓存（简单实现：sessionStorage，key = url+params md5；value 存储 { ts, ttl, data }） */
+function cacheKeyFor(url, params) {
+    try {
+        return md5(url + JSON.stringify(params || {}));
+    }
+    catch {
+        return md5(url + String(params));
+    }
+}
+function setCache(key, payload, ttl) {
+    const item = {
+        ts: Date.now(),
+        ttl,
+        payload,
+    };
+    try {
+        sessionStorage.setItem(`_http_cache_${key}`, JSON.stringify(item));
+    }
+    catch {
+        // ignore
+    }
+}
+function getCache(key) {
+    try {
+        const raw = sessionStorage.getItem(`_http_cache_${key}`);
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        if (Date.now() - parsed.ts > parsed.ttl) {
+            sessionStorage.removeItem(`_http_cache_${key}`);
+            return null;
+        }
+        return parsed.payload;
+    }
+    catch {
+        return null;
+    }
+}
+/** 生成或获取 UDID */
+export async function generateUdid() {
     const udidFromUrl = getParams("udid");
     const localFinger = Local("finger");
     if (udidFromUrl) {
-        // 若 URL 参数 udid 与本地不一致，清除旧的密钥缓存
         if (localFinger && localFinger !== udidFromUrl) {
             localStorage.removeItem("SkeyData");
         }
@@ -20,25 +118,54 @@ async function getFinger() {
         return udidFromUrl;
     }
     if (localFinger)
-        return localFinger;
-    const newId = generateUdid();
+        return Promise.resolve(localFinger);
+    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    const newId = Array.from({ length: 32 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join("");
     Local("finger", newId);
     return newId;
 }
-/** 通用 HTTP 请求封装 */
-export async function HttpServer(endpoint, params = {}, method = "GET") {
-    const udid = await getFinger();
+/**
+ * 核心请求函数
+ * @param endpoint 接口路径（相对或绝对）
+ * @param params GET 的 query 或 POST 的 body（如果需要同时指定 query/body，请将参数组织为 { query: {...}, body: {...} }）
+ * @param method HTTP 方法
+ * @param options 可选项（超时、重试、缓存等）
+ * @returns Promise<HttpResult<T>> （默认 unwrap=false 会返回完整 wrapper。unwrap=true 则返回 data 内容）
+ */
+export async function HttpServer(endpoint, params = {}, method = "GET", options = {}) {
+    // 合并默认 options
+    const retry = options.retry ?? globalConfig.defaultRetry;
+    const retryDelay = options.retryDelay ?? globalConfig.defaultRetryDelay;
+    const timeout = options.timeout ?? globalConfig.defaultTimeout;
+    const debug = options.debug ?? globalConfig.debug ?? false;
+    const unwrap = options.unwrap ?? false;
+    const responseType = options.responseType ?? "json";
+    const isFormData = options.isFormData ?? false;
+    // 支持 params 拆分 query / body 的场景
+    let queryParams = {};
+    let bodyParams = {};
+    if (params &&
+        typeof params === "object" &&
+        ("query" in params || "body" in params)) {
+        queryParams = params.query || {};
+        bodyParams = params.body || {};
+    }
+    else {
+        if (method === "GET")
+            queryParams = params || {};
+        else
+            bodyParams = params || {};
+    }
+    // 生成 UDID / 签名 / baseUrl
+    const udid = await generateUdid();
     const baseUrl = HF.getBaseUrl();
     const fullUrl = new URL(endpoint, baseUrl).toString();
     const timestamp = Date.now();
     const lang = getParams("lang") || "YN";
-    // 基础请求体
-    const data = {
-        ...params,
+    // 组装公共字段（注意：不强制覆盖用户 bodyParams）
+    const baseFields = {
         language: lang,
         timestamp,
-        sign: md5(udid + "jgyh,kasd" + timestamp),
-        paySign: md5(udid.substring(0, 6) + "8qiezi" + timestamp),
         currentUserAppVersion: "2.0.5",
         channel: "",
         version: "1.0.0",
@@ -47,18 +174,38 @@ export async function HttpServer(endpoint, params = {}, method = "GET") {
         deviceType: "1",
         udid,
     };
-    // Header
+    const sign = globalConfig.signFn
+        ? globalConfig.signFn(udid, timestamp)
+        : md5(udid + "jgyh,kasd" + timestamp);
+    const paySign = globalConfig.paySignFn
+        ? globalConfig.paySignFn(udid, timestamp)
+        : md5(udid.substring(0, 6) + "8qiezi" + timestamp);
+    // 合并 body（不覆盖传入的 bodyParams）
+    const finalBody = {
+        ...baseFields,
+        ...bodyParams,
+        sign,
+        paySign,
+    };
+    // 构建 headers
     const headers = {
         "X-UDID": udid,
         "X-Timestamp": String(timestamp),
         "X-Language": lang,
-        "X-Sign": data.sign,
+        "X-Sign": sign,
         "Accept-Language": lang,
         tenantSys: HF.getTenant(),
-        "Content-Type": "application/json",
-        os: data.os,
+        os: finalBody.os,
+        ...options.headers,
     };
-    // 附加 URL 参数（如 puid、id、token）
+    // token
+    const token = Local("token") || getParams("token");
+    if (token) {
+        headers.Authorization = `HSBox ${token}`;
+        // 也放入 finalBody 保持兼容
+        finalBody.token = token;
+    }
+    // 额外 URL 参数（将附加到 headers 以保持与原逻辑一致）
     const allParams = getParams();
     Object.entries(allParams).forEach(([k, v]) => {
         if (v)
@@ -67,35 +214,263 @@ export async function HttpServer(endpoint, params = {}, method = "GET") {
     const puid = getParams("puid") || getParams("id");
     if (puid)
         headers.puid = puid;
-    const token = Local("token") || getParams("token");
-    if (token) {
-        headers.Authorization = `HSBox ${token}`;
-        data.token = token;
+    // 处理 URL（GET 时把 queryParams 拼接）
+    const url = method === "GET"
+        ? `${fullUrl}${Object.keys(queryParams || {}).length
+            ? "?" +
+                new URLSearchParams(Object.entries(queryParams).map(([k, v]) => [k, String(v)])).toString()
+            : ""}`
+        : fullUrl;
+    // 缓存 key（仅 GET）
+    const cacheOption = options.cache;
+    const cacheTTL = typeof cacheOption === "number"
+        ? cacheOption
+        : cacheOption
+            ? globalConfig.defaultCacheTTL
+            : 0;
+    const cacheKey = cacheTTL ? cacheKeyFor(url, queryParams) : "";
+    // 命中缓存直接返回（按 unwrap 处理）
+    if (cacheTTL) {
+        const cached = getCache(cacheKey);
+        if (cached !== null) {
+            if (debug)
+                console.info("[http][cache-hit]", url);
+            if (unwrap)
+                return cached;
+            return {
+                code: 200,
+                msg: "ok (cache)",
+                data: cached,
+            };
+        }
     }
-    // 拼接请求
-    try {
-        const url = method === "GET"
-            ? `${fullUrl}${Object.keys(params).length
-                ? "?" +
-                    new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString()
-                : ""}`
-            : fullUrl;
-        const res = await fetch(url, {
-            method,
-            headers,
-            ...(method !== "GET" && { body: JSON.stringify(data) }),
-        });
-        const text = await res.text();
-        const json = JSON.parse(text);
-        if (json.code === 0 || json.code === 200) {
-            return json.data;
+    // 如果不是 FormData，Content-Type: application/json
+    if (!isFormData)
+        headers["Content-Type"] = "application/json";
+    // body 构建
+    const body = method !== "GET"
+        ? isFormData
+            ? (() => {
+                const fm = new FormData();
+                Object.entries(finalBody).forEach(([k, v]) => {
+                    if (v === undefined || v === null)
+                        return;
+                    fm.append(k, v);
+                });
+                return fm;
+            })()
+            : JSON.stringify(finalBody)
+        : undefined;
+    // 请求拦截器执行
+    for (const interceptor of globalConfig.requestInterceptors || []) {
+        try {
+            await interceptor({ url, method, params: finalBody, headers, options });
         }
-        else {
-            throw new Error(json.msg || "Request failed");
+        catch (e) {
+            // 拦截器抛错则中断请求
+            throw e;
         }
     }
-    catch (err) {
-        console.error("[HttpServer Error]", err);
-        throw err;
+    // 真实 fetch 执行封装（含 retry + timeout）
+    let attempt = 0;
+    let lastErr = null;
+    while (attempt <= retry) {
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            if (debug) {
+                console.info(`[http][request] ${method} ${url}`, {
+                    headers,
+                    bodyPreview: isFormData
+                        ? "FormData"
+                        : body
+                            ? String(body).slice(0, 200)
+                            : undefined,
+                });
+            }
+            const res = await fetch(url, { method, headers, body, signal });
+            clearTimeout(timeoutId);
+            // 根据 responseType 解析
+            let parsed;
+            if (responseType === "blob") {
+                parsed = await res.blob();
+                // 对 blob 无法做 json wrapper 检查，直接返回
+                if (debug)
+                    console.info(`[http][response][blob] ${url}`);
+                const result = {
+                    code: res.status,
+                    msg: res.statusText,
+                    data: parsed,
+                    raw: parsed,
+                };
+                // 缓存（不缓存 blob）
+                // 执行响应拦截器
+                for (const ri of globalConfig.responseInterceptors || []) {
+                    try {
+                        await ri({
+                            url,
+                            method,
+                            params: finalBody,
+                            headers,
+                            options,
+                            response: { code: res.status, msg: res.statusText, data: parsed },
+                        });
+                    }
+                    catch (e) {
+                        /* ignore interceptor error */
+                    }
+                }
+                if (unwrap)
+                    return parsed;
+                return result;
+            }
+            else if (responseType === "text") {
+                const text = await res.text();
+                parsed = text;
+                // 尝试将 text 转为 json wrapper（如果是 JSON 字符串）
+                let wrapper = null;
+                try {
+                    wrapper = JSON.parse(text);
+                }
+                catch {
+                    wrapper = null;
+                }
+                if (wrapper && wrapper.code !== undefined) {
+                    // fallthrough to wrapper handling below
+                    const w = wrapper;
+                    // 响应拦截
+                    for (const ri of globalConfig.responseInterceptors || []) {
+                        try {
+                            await ri({
+                                url,
+                                method,
+                                params: finalBody,
+                                headers,
+                                options,
+                                response: w,
+                            });
+                        }
+                        catch (e) { }
+                    }
+                    if (w.code === 0 || w.code === 200) {
+                        // 缓存处理
+                        if (cacheTTL)
+                            setCache(cacheKey, w.data, cacheTTL);
+                        if (unwrap)
+                            return w.data;
+                        return {
+                            code: w.code,
+                            msg: w.msg,
+                            data: w.data,
+                            raw: w,
+                        };
+                    }
+                    else {
+                        throw new HttpBusinessError(w.code, w.msg || "Business error", w.data);
+                    }
+                }
+                else {
+                    // text but not wrapper
+                    if (unwrap)
+                        return parsed;
+                    return {
+                        code: res.status,
+                        msg: res.statusText,
+                        data: parsed,
+                        raw: parsed,
+                    };
+                }
+            }
+            else {
+                // 默认 json
+                const text = await res.text();
+                let jsonWrapper;
+                try {
+                    jsonWrapper = JSON.parse(text);
+                }
+                catch (e) {
+                    throw new HttpNetworkError("Invalid JSON response", text);
+                }
+                // 执行响应拦截器（可抛错）
+                for (const ri of globalConfig.responseInterceptors || []) {
+                    try {
+                        await ri({
+                            url,
+                            method,
+                            params: finalBody,
+                            headers,
+                            options,
+                            response: jsonWrapper,
+                        });
+                    }
+                    catch (e) {
+                        // 拦截器决定中断或修改
+                    }
+                }
+                if (jsonWrapper.code === 0 || jsonWrapper.code === 200) {
+                    // 缓存（仅 GET）
+                    if (cacheTTL && method === "GET") {
+                        setCache(cacheKey, jsonWrapper.data, cacheTTL);
+                    }
+                    if (debug)
+                        console.info(`[http][response][ok] ${url}`, jsonWrapper);
+                    if (unwrap)
+                        return jsonWrapper.data;
+                    return {
+                        code: jsonWrapper.code,
+                        msg: jsonWrapper.msg,
+                        data: jsonWrapper.data,
+                        raw: jsonWrapper,
+                    };
+                }
+                else {
+                    // 业务错误
+                    throw new HttpBusinessError(jsonWrapper.code, jsonWrapper.msg || "Business error", jsonWrapper.data);
+                }
+            }
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            lastErr = err;
+            // 区分 AbortError（超时）和其他
+            if (err && err.name === "AbortError") {
+                lastErr = new HttpTimeoutError("Request timeout", err);
+            }
+            else if (err instanceof HttpBusinessError) {
+                // 业务错误，不触发重试（通常业务错误不会通过重试解决）
+                // 触发全局错误拦截器
+                for (const ei of globalConfig.errorInterceptors || []) {
+                    try {
+                        await ei(err);
+                    }
+                    catch { }
+                }
+                // 直接抛出
+                throw err;
+            }
+            else {
+                // 网络错误（如断网、解析失败等）
+                lastErr = new HttpNetworkError(err?.message || "Network error", err);
+            }
+            // 执行错误拦截器
+            for (const ei of globalConfig.errorInterceptors || []) {
+                try {
+                    await ei(lastErr);
+                }
+                catch { }
+            }
+            attempt++;
+            if (attempt > retry)
+                break;
+            // 等待 retryDelay
+            await new Promise((r) => setTimeout(r, retryDelay));
+            if (debug)
+                console.warn(`[http][retry] ${method} ${url} attempt ${attempt}/${retry}`);
+        }
     }
+    // 全部失败后统一抛出最后的错误
+    if (debug)
+        console.error("[http][fail]", lastErr);
+    throw lastErr;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hifun-tools",
-  "version": "1.2.11",
+  "version": "1.3.1",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,5 +17,8 @@
   "devDependencies": {
     "md5": "^2.3.0",
     "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "crypto-js": "^4.2.0"
   }
 }