xxf_react 0.6.7 → 0.6.8

package/dist/http/cache/HttpCache.d.ts

@@ -0,0 +1,59 @@
+/**
+ * HTTP 缓存（内存 + 磁盘双层）
+ *
+ * 策略：
+ * - 读取：先内存 -> 再磁盘 -> 若磁盘命中则回填内存
+ * - 写入：同时写入内存和磁盘
+ * - 容错：缓存操作失败不影响正常业务
+ * - 防污染：返回数据的深拷贝，防止上层修改影响缓存
+ */
+import { DiskLruCache } from './DiskLruCache';
+import type { CacheEntry, HttpCacheConfig } from '../types';
+export declare class HttpCache {
+    private memoryCache;
+    private diskCache;
+    constructor(config: HttpCacheConfig);
+    /**
+     * 获取缓存
+     * @param key 缓存 key
+     * @returns 缓存条目的深拷贝，未命中或失败返回 null
+     */
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    /**
+     * 设置缓存（失败静默忽略，不影响业务）
+     * @param key 缓存 key
+     * @param data 数据
+     * @param ttl 过期时间 (ms)
+     */
+    set<T>(key: string, data: T, ttl?: number): Promise<void>;
+    /**
+     * 删除缓存（失败静默忽略）
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * 清空所有缓存（失败静默忽略）
+     */
+    clear(): Promise<void>;
+    /**
+     * 仅获取内存缓存（同步，失败返回 null）
+     * @returns 缓存条目的深拷贝
+     */
+    getFromMemory<T>(key: string): CacheEntry<T> | null;
+    /**
+     * 仅设置内存缓存（同步，失败静默忽略）
+     */
+    setToMemory<T>(key: string, data: T, ttl?: number): void;
+    /**
+     * 检查缓存是否存在（会检查过期，失败返回 false）
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * 获取磁盘缓存实例（用于高级操作）
+     */
+    getDiskCache(): DiskLruCache;
+    /**
+     * 刷新磁盘缓存元数据（失败静默忽略）
+     */
+    flush(): Promise<void>;
+}
+//# sourceMappingURL=HttpCache.d.ts.map

package/dist/http/cache/HttpCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpCache.d.ts","sourceRoot":"","sources":["../../../src/http/cache/HttpCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG3D,qBAAa,SAAS;IAClB,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,SAAS,CAAc;gBAEnB,MAAM,EAAE,eAAe;IAcnC;;;;OAIG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAwCxD;;;;;OAKG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,GAAE,MAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBlE;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B;;;OAGG;IACH,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;IAgBnD;;OAEG;IACH,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,GAAE,MAAU,GAAG,IAAI;IAc3D;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAyBxC;;OAEG;IACH,YAAY,IAAI,YAAY;IAI5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO/B"}

package/dist/http/cache/HttpCache.js

@@ -0,0 +1,215 @@
+/**
+ * HTTP 缓存（内存 + 磁盘双层）
+ *
+ * 策略：
+ * - 读取：先内存 -> 再磁盘 -> 若磁盘命中则回填内存
+ * - 写入：同时写入内存和磁盘
+ * - 容错：缓存操作失败不影响正常业务
+ * - 防污染：返回数据的深拷贝，防止上层修改影响缓存
+ */
+import { lru } from 'tiny-lru';
+import { DiskLruCache } from './DiskLruCache';
+import { copy } from '../../foundation';
+export class HttpCache {
+    constructor(config) {
+        // 初始化内存缓存
+        // 注意：不使用 tiny-lru 的 ttl 参数，因为每个 entry 有自己的 ttl
+        // tiny-lru 的 ttl 是全局的，会导致冲突
+        this.memoryCache = lru(config.memoryMaxSize);
+        // 初始化磁盘缓存
+        this.diskCache = new DiskLruCache({
+            dbName: config.dbName,
+            storeName: 'http-cache',
+            maxSize: config.diskMaxSize,
+        });
+    }
+    /**
+     * 获取缓存
+     * @param key 缓存 key
+     * @returns 缓存条目的深拷贝，未命中或失败返回 null
+     */
+    async get(key) {
+        // 1. 先查内存（内存操作用 try-catch 保护）
+        try {
+            const memEntry = this.memoryCache.get(key);
+            if (memEntry) {
+                // 检查是否过期
+                if (memEntry.ttl > 0 &&
+                    Date.now() - memEntry.timestamp > memEntry.ttl) {
+                    this.memoryCache.delete(key);
+                }
+                else {
+                    // 返回深拷贝，防止上层修改污染缓存
+                    return copy(memEntry);
+                }
+            }
+        }
+        catch {
+            // 内存缓存读取失败，继续尝试磁盘
+        }
+        // 2. 再查磁盘（磁盘操作失败返回 null，不影响业务）
+        try {
+            const diskEntry = await this.diskCache.get(key);
+            if (diskEntry) {
+                // 回填内存缓存（失败也忽略）
+                try {
+                    this.memoryCache.set(key, diskEntry);
+                }
+                catch {
+                    // 回填失败忽略
+                }
+                // 返回深拷贝，防止上层修改污染缓存
+                return copy(diskEntry);
+            }
+        }
+        catch {
+            // 磁盘缓存读取失败，返回 null
+        }
+        return null;
+    }
+    /**
+     * 设置缓存（失败静默忽略，不影响业务）
+     * @param key 缓存 key
+     * @param data 数据
+     * @param ttl 过期时间 (ms)
+     */
+    async set(key, data, ttl = 0) {
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            ttl,
+            key,
+        };
+        // 写入内存（失败忽略）
+        try {
+            this.memoryCache.set(key, entry);
+        }
+        catch {
+            // 内存写入失败忽略
+        }
+        // 写入磁盘（失败忽略）
+        try {
+            await this.diskCache.set(key, data, ttl);
+        }
+        catch {
+            // 磁盘写入失败忽略，不影响业务
+        }
+    }
+    /**
+     * 删除缓存（失败静默忽略）
+     */
+    async delete(key) {
+        try {
+            this.memoryCache.delete(key);
+        }
+        catch {
+            // 忽略
+        }
+        try {
+            await this.diskCache.delete(key);
+        }
+        catch {
+            // 忽略
+        }
+    }
+    /**
+     * 清空所有缓存（失败静默忽略）
+     */
+    async clear() {
+        try {
+            this.memoryCache.clear();
+        }
+        catch {
+            // 忽略
+        }
+        try {
+            await this.diskCache.clear();
+        }
+        catch {
+            // 忽略
+        }
+    }
+    /**
+     * 仅获取内存缓存（同步，失败返回 null）
+     * @returns 缓存条目的深拷贝
+     */
+    getFromMemory(key) {
+        try {
+            const entry = this.memoryCache.get(key);
+            if (!entry)
+                return null;
+            if (entry.ttl > 0 && Date.now() - entry.timestamp > entry.ttl) {
+                this.memoryCache.delete(key);
+                return null;
+            }
+            // 返回深拷贝，防止上层修改污染缓存
+            return copy(entry);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 仅设置内存缓存（同步，失败静默忽略）
+     */
+    setToMemory(key, data, ttl = 0) {
+        try {
+            const entry = {
+                data,
+                timestamp: Date.now(),
+                ttl,
+                key,
+            };
+            this.memoryCache.set(key, entry);
+        }
+        catch {
+            // 忽略
+        }
+    }
+    /**
+     * 检查缓存是否存在（会检查过期，失败返回 false）
+     */
+    async has(key) {
+        // 先查内存
+        try {
+            const memEntry = this.memoryCache.get(key);
+            if (memEntry) {
+                // 检查是否过期
+                if (memEntry.ttl > 0 && Date.now() - memEntry.timestamp > memEntry.ttl) {
+                    this.memoryCache.delete(key);
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // 内存检查失败，继续检查磁盘
+        }
+        // 再查磁盘
+        try {
+            const diskEntry = await this.diskCache.get(key);
+            return diskEntry !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 获取磁盘缓存实例（用于高级操作）
+     */
+    getDiskCache() {
+        return this.diskCache;
+    }
+    /**
+     * 刷新磁盘缓存元数据（失败静默忽略）
+     */
+    async flush() {
+        try {
+            await this.diskCache.flush();
+        }
+        catch {
+            // 忽略
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export { DiskLruCache } from './DiskLruCache';
+export { HttpCache } from './HttpCache';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http/cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/dist/http/cache/index.js

@@ -0,0 +1,2 @@
+export { DiskLruCache } from './DiskLruCache';
+export { HttpCache } from './HttpCache';

package/dist/http/client/ApiStream.d.ts

@@ -0,0 +1,80 @@
+/**
+ * ApiStream - AsyncGenerator 流式响应
+ *
+ * 支持三种消费方式：
+ * 1. await - 直接获取最后一个结果
+ * 2. for await - 迭代所有结果
+ * 3. subscribe - 安全消费（框架 try-catch）
+ */
+import type { ApiResult, ApiCallback } from '../types';
+export declare class ApiStream<T> implements AsyncIterable<ApiResult<T>>, PromiseLike<T> {
+    private generator;
+    private consumed;
+    constructor(generator: () => AsyncGenerator<ApiResult<T>>);
+    /**
+     * 实现 AsyncIterable，支持 for await
+     *
+     * 注意：每次迭代都会创建新的请求。如果需要缓存结果，请使用 toArray()
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<ApiResult<T>>;
+    /**
+     * 实现 PromiseLike，支持直接 await（返回最后一个结果的 data）
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    /**
+     * 实现 catch
+     */
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    /**
+     * 实现 finally
+     */
+    finally(onfinally?: (() => void) | null): Promise<T>;
+    /**
+     * 获取第一个结果
+     * @throws 如果没有结果会抛出错误
+     */
+    first(): Promise<ApiResult<T>>;
+    /**
+     * 获取第一个结果，没有则返回 null
+     */
+    firstOrNull(): Promise<ApiResult<T> | null>;
+    /**
+     * 获取最后一个结果
+     * @throws 如果没有结果会抛出错误
+     */
+    last(): Promise<ApiResult<T>>;
+    /**
+     * 获取最后一个结果，没有则返回 null
+     */
+    lastOrNull(): Promise<ApiResult<T> | null>;
+    /**
+     * 获取所有结果
+     */
+    toArray(): Promise<ApiResult<T>[]>;
+    /**
+     * 查找满足条件的第一个结果
+     */
+    find(predicate: (result: ApiResult<T>) => boolean): Promise<ApiResult<T> | undefined>;
+    /**
+     * 安全消费（框架 try-catch 隔离错误）
+     * onData 抛错不会影响后续 yield
+     */
+    subscribe(callback: ApiCallback<T>): Promise<void>;
+    /**
+     * 映射结果
+     */
+    map<U>(fn: (data: T) => U): ApiStream<U>;
+    /**
+     * 过滤结果
+     */
+    filter(predicate: (result: ApiResult<T>) => boolean): ApiStream<T>;
+    /**
+     * 只获取缓存结果
+     */
+    cacheOnly(): ApiStream<T>;
+    /**
+     * 只获取网络结果
+     */
+    remoteOnly(): ApiStream<T>;
+}
+//# sourceMappingURL=ApiStream.d.ts.map

package/dist/http/client/ApiStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiStream.d.ts","sourceRoot":"","sources":["../../../src/http/client/ApiStream.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtD,qBAAa,SAAS,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IAC5E,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,QAAQ,CAAQ;gBAEZ,SAAS,EAAE,MAAM,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAIzD;;;;OAIG;IACH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAqBtD;;OAEG;IACH,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,KAAK,EAC/B,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,EACrE,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,GAC5E,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAM/B;;OAEG;IACH,KAAK,CAAC,OAAO,GAAG,KAAK,EACjB,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,GAC1E,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;IAIvB;;OAEG;IACH,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC;IAapD;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAQpC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAOjD;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAQnC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAQhD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAQxC;;OAEG;IACG,IAAI,CACN,SAAS,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,OAAO,GAC7C,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IASpC;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBxD;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAYxC;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC;IAWlE;;OAEG;IACH,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC;IAIzB;;OAEG;IACH,UAAU,IAAI,SAAS,CAAC,CAAC,CAAC;CAG7B"}

package/dist/http/client/ApiStream.js

@@ -0,0 +1,190 @@
+/**
+ * ApiStream - AsyncGenerator 流式响应
+ *
+ * 支持三种消费方式：
+ * 1. await - 直接获取最后一个结果
+ * 2. for await - 迭代所有结果
+ * 3. subscribe - 安全消费（框架 try-catch）
+ */
+export class ApiStream {
+    constructor(generator) {
+        this.consumed = false;
+        this.generator = generator;
+    }
+    /**
+     * 实现 AsyncIterable，支持 for await
+     *
+     * 注意：每次迭代都会创建新的请求。如果需要缓存结果，请使用 toArray()
+     */
+    [Symbol.asyncIterator]() {
+        var _a;
+        if (this.consumed) {
+            // 开发环境下警告重复消费
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (typeof globalThis.process !== 'undefined' &&
+                    ((_a = globalThis.process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) !== 'production') {
+                    console.warn('[ApiStream] Stream is being consumed multiple times. ' +
+                        'Each iteration creates a new request. ' +
+                        'Use toArray() if you need to reuse results.');
+                }
+            }
+            catch {
+                // 忽略环境检测错误
+            }
+        }
+        this.consumed = true;
+        return this.generator();
+    }
+    /**
+     * 实现 PromiseLike，支持直接 await（返回最后一个结果的 data）
+     */
+    then(onfulfilled, onrejected) {
+        return this.last()
+            .then((result) => result.data)
+            .then(onfulfilled, onrejected);
+    }
+    /**
+     * 实现 catch
+     */
+    catch(onrejected) {
+        return this.then(undefined, onrejected);
+    }
+    /**
+     * 实现 finally
+     */
+    finally(onfinally) {
+        return this.then((value) => {
+            onfinally === null || onfinally === void 0 ? void 0 : onfinally();
+            return value;
+        }, (reason) => {
+            onfinally === null || onfinally === void 0 ? void 0 : onfinally();
+            throw reason;
+        });
+    }
+    /**
+     * 获取第一个结果
+     * @throws 如果没有结果会抛出错误
+     */
+    async first() {
+        const result = await this.firstOrNull();
+        if (!result) {
+            throw new Error('No result available');
+        }
+        return result;
+    }
+    /**
+     * 获取第一个结果，没有则返回 null
+     */
+    async firstOrNull() {
+        for await (const result of this) {
+            return result;
+        }
+        return null;
+    }
+    /**
+     * 获取最后一个结果
+     * @throws 如果没有结果会抛出错误
+     */
+    async last() {
+        const result = await this.lastOrNull();
+        if (!result) {
+            throw new Error('No result available');
+        }
+        return result;
+    }
+    /**
+     * 获取最后一个结果，没有则返回 null
+     */
+    async lastOrNull() {
+        let lastResult = null;
+        for await (const result of this) {
+            lastResult = result;
+        }
+        return lastResult;
+    }
+    /**
+     * 获取所有结果
+     */
+    async toArray() {
+        const results = [];
+        for await (const result of this) {
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * 查找满足条件的第一个结果
+     */
+    async find(predicate) {
+        for await (const result of this) {
+            if (predicate(result)) {
+                return result;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 安全消费（框架 try-catch 隔离错误）
+     * onData 抛错不会影响后续 yield
+     */
+    async subscribe(callback) {
+        var _a, _b, _c, _d;
+        try {
+            for await (const result of this) {
+                try {
+                    callback.onData(result.data, result.fromCache);
+                }
+                catch (error) {
+                    // 捕获下游错误，不影响后续 yield
+                    (_a = callback.onError) === null || _a === void 0 ? void 0 : _a.call(callback, error);
+                }
+            }
+            (_b = callback.onComplete) === null || _b === void 0 ? void 0 : _b.call(callback);
+        }
+        catch (error) {
+            // 网络错误等
+            (_c = callback.onError) === null || _c === void 0 ? void 0 : _c.call(callback, error);
+            (_d = callback.onComplete) === null || _d === void 0 ? void 0 : _d.call(callback);
+        }
+    }
+    /**
+     * 映射结果
+     */
+    map(fn) {
+        const self = this;
+        return new ApiStream(async function* () {
+            for await (const result of self) {
+                yield {
+                    data: fn(result.data),
+                    fromCache: result.fromCache,
+                };
+            }
+        });
+    }
+    /**
+     * 过滤结果
+     */
+    filter(predicate) {
+        const self = this;
+        return new ApiStream(async function* () {
+            for await (const result of self) {
+                if (predicate(result)) {
+                    yield result;
+                }
+            }
+        });
+    }
+    /**
+     * 只获取缓存结果
+     */
+    cacheOnly() {
+        return this.filter((r) => r.fromCache);
+    }
+    /**
+     * 只获取网络结果
+     */
+    remoteOnly() {
+        return this.filter((r) => !r.fromCache);
+    }
+}

package/dist/http/client/HttpClient.d.ts

@@ -0,0 +1,88 @@
+/**
+ * HTTP 客户端
+ *
+ * 基于 ky 封装，支持：
+ * - 多种缓存模式
+ * - 自动重试
+ * - 超时处理
+ */
+import { type KyInstance, type Options as KyOptions } from 'ky';
+import { HttpCache } from '../cache/HttpCache';
+import { ApiStream } from './ApiStream';
+import { type HttpClientConfig, type RequestConfig, type ApiOptions } from '../types';
+export declare class HttpClient {
+    private client;
+    private cache;
+    private config;
+    constructor(config: HttpClientConfig);
+    /**
+     * 获取 ky 实例（用于扩展 hooks 等）
+     */
+    getKyInstance(): KyInstance;
+    /**
+     * 设置 ky 实例
+     */
+    setKyInstance(instance: KyInstance): void;
+    /**
+     * 扩展 ky 实例
+     */
+    extendKy(options: KyOptions): void;
+    /**
+     * 执行请求，返回 ApiStream
+     */
+    request<T>(requestConfig: RequestConfig, options?: ApiOptions): ApiStream<T>;
+    /**
+     * 根据缓存策略执行请求
+     */
+    private executeWithCacheStrategy;
+    /**
+     * 判断响应是否应该缓存
+     *
+     * 调用全局缓存拦截器，根据响应内容决定是否缓存。
+     * 如果没有配置拦截器，默认允许缓存。
+     *
+     * @param result 请求响应结果
+     * @param cacheKey 缓存 key
+     * @param request 请求信息
+     * @param defaultTtl 默认 TTL
+     * @returns 是否缓存及最终 TTL
+     */
+    private shouldCacheResponse;
+    /**
+     * 条件缓存：根据拦截器结果决定是否写入缓存
+     */
+    private conditionalCache;
+    /**
+     * OnlyRemote: 只从服务器拿
+     */
+    private strategyOnlyRemote;
+    /**
+     * OnlyCache: 只从缓存拿
+     */
+    private strategyOnlyCache;
+    /**
+     * IfCache: 有缓存返回缓存，否则请求网络
+     */
+    private strategyIfCache;
+    /**
+     * FirstRemote: 先从服务器获取，没网络则读缓存
+     */
+    private strategyFirstRemote;
+    /**
+     * FirstCache: 先从本地缓存拿，然后从服务器拿，可能 yield 两次
+     */
+    private strategyFirstCache;
+    /**
+     * LastCache: 读上次缓存，没有则返回网络并同步缓存；有缓存也会后台同步网络但不 yield
+     */
+    private strategyLastCache;
+    /**
+     * 获取缓存实例（用于高级操作）
+     */
+    getCache(): HttpCache;
+    /**
+     * 清空所有缓存
+     */
+    clearCache(): Promise<void>;
+}
+//# sourceMappingURL=HttpClient.d.ts.map

package/dist/http/client/HttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.d.ts","sourceRoot":"","sources":["../../../src/http/client/HttpClient.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAW,EAAE,KAAK,UAAU,EAAE,KAAK,OAAO,IAAI,SAAS,EAAE,MAAM,IAAI,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAEH,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,UAAU,EAMlB,MAAM,UAAU,CAAA;AAyFjB,qBAAa,UAAU;IACnB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,gBAAgB;IA8BpC;;OAEG;IACH,aAAa,IAAI,UAAU;IAI3B;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI;IAIzC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IAIlC;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAAC,CAAC,CAAC;IAmFhF;;OAEG;YACY,wBAAwB;IAqCvC;;;;;;;;;;;OAWG;YACW,mBAAmB;IAwCjC;;OAEG;YACW,gBAAgB;IAY9B;;OAEG;YACY,kBAAkB;IAWjC;;OAEG;YACY,iBAAiB;IAQhC;;OAEG;YACY,eAAe;IAiB9B;;OAEG;YACY,mBAAmB;IAqBlC;;OAEG;YACY,kBAAkB;IA0BjC;;OAEG;YACY,iBAAiB;IA0BhC;;OAEG;IACH,QAAQ,IAAI,SAAS;IAIrB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAGpC"}