xxf_react 0.6.7 → 0.6.9

package/dist/http/client/HttpClient.js

@@ -0,0 +1,381 @@
+/**
+ * HTTP 客户端
+ *
+ * 基于 ky 封装，支持：
+ * - 多种缓存模式
+ * - 自动重试
+ * - 超时处理
+ */
+import ky from 'ky';
+import { HttpCache } from '../cache/HttpCache';
+import { ApiStream } from './ApiStream';
+import { CacheMode, } from '../types';
+/**
+ * 对象 key 排序（用于生成稳定的缓存 key）
+ * 支持嵌套对象递归排序
+ */
+function sortKeys(obj) {
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+        const value = obj[key];
+        // 递归处理嵌套对象（排除 null 和数组）
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            sorted[key] = sortKeys(value);
+        }
+        else {
+            sorted[key] = value;
+        }
+    }
+    return sorted;
+}
+/**
+ * 简单 hash 函数
+ */
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(36);
+}
+/**
+ * 过滤对象中的 undefined 和 null 值
+ */
+function filterUndefined(obj) {
+    if (!obj)
+        return undefined;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== undefined && value !== null) {
+            result[key] = String(value);
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/**
+ * 默认缓存 key 生成
+ */
+function defaultGenerateCacheKey(request, keyHeaders) {
+    const parts = [request.method, request.path];
+    if (request.query && Object.keys(request.query).length > 0) {
+        parts.push(JSON.stringify(sortKeys(request.query)));
+    }
+    if (request.body) {
+        parts.push(simpleHash(JSON.stringify(request.body)));
+    }
+    if ((keyHeaders === null || keyHeaders === void 0 ? void 0 : keyHeaders.length) && request.headers) {
+        const headerParts = keyHeaders
+            .filter((k) => request.headers[k])
+            .map((k) => `${k}:${request.headers[k]}`)
+            .join('|');
+        if (headerParts) {
+            parts.push(headerParts);
+        }
+    }
+    return parts.join(':');
+}
+export class HttpClient {
+    constructor(config) {
+        this.config = {
+            headers: {},
+            timeout: 30000,
+            retry: 2,
+            memoryCacheMaxSize: 100,
+            diskCacheMaxSize: 500,
+            dbName: 'xxf-http-cache',
+            defaultKeyHeaders: ['Authorization'],
+            defaultCache: undefined, // 默认不缓存 (OnlyRemote)
+            cacheInterceptor: undefined, // 默认无拦截器
+            ...config,
+        };
+        // 初始化 ky 实例
+        this.client = ky.create({
+            prefixUrl: this.config.baseUrl,
+            timeout: this.config.timeout,
+            retry: this.config.retry,
+            headers: this.config.headers,
+        });
+        // 初始化双层缓存
+        this.cache = new HttpCache({
+            memoryMaxSize: this.config.memoryCacheMaxSize,
+            diskMaxSize: this.config.diskCacheMaxSize,
+            dbName: this.config.dbName,
+        });
+    }
+    /**
+     * 获取 ky 实例（用于扩展 hooks 等）
+     */
+    getKyInstance() {
+        return this.client;
+    }
+    /**
+     * 设置 ky 实例
+     */
+    setKyInstance(instance) {
+        this.client = instance;
+    }
+    /**
+     * 扩展 ky 实例
+     */
+    extendKy(options) {
+        this.client = this.client.extend(options);
+    }
+    /**
+     * 执行请求，返回 ApiStream
+     */
+    request(requestConfig, options = {}) {
+        const self = this;
+        return new ApiStream(async function* () {
+            const { method, path, headers: configHeaders, timeout, cache: cacheConfig, retry } = requestConfig;
+            const { pathParams, query, body, cache: overrideCache, headers: optionHeaders } = options;
+            // 替换路径参数（自动 URL 编码）
+            let url = path;
+            if (pathParams) {
+                for (const [key, value] of Object.entries(pathParams)) {
+                    url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+                }
+            }
+            // 合并 headers
+            const mergedHeaders = {
+                ...self.config.headers,
+                ...configHeaders,
+                ...optionHeaders,
+            };
+            // 合并缓存配置（优先级：调用时覆盖 > 接口配置 > 全局默认 > 硬编码默认）
+            const finalCacheConfig = {
+                mode: CacheMode.OnlyRemote,
+                ttl: 5 * 60 * 1000, // 默认 5 分钟
+                keyHeaders: self.config.defaultKeyHeaders,
+                ...self.config.defaultCache, // 全局默认缓存配置
+                ...cacheConfig, // 接口级配置
+                ...overrideCache, // 调用时覆盖
+            };
+            // 生成缓存 key
+            const cacheKeyRequest = {
+                method,
+                path: url,
+                query: query,
+                body,
+                headers: mergedHeaders,
+                pathParams,
+            };
+            const cacheKey = finalCacheConfig.cacheKey
+                ? finalCacheConfig.cacheKey(cacheKeyRequest)
+                : defaultGenerateCacheKey(cacheKeyRequest, finalCacheConfig.keyHeaders);
+            // 过滤 query 参数中的 undefined/null
+            const filteredQuery = filterUndefined(query);
+            // 请求函数（返回完整响应信息，供缓存拦截器使用）
+            const doRequest = async () => {
+                const kyOptions = {
+                    method: method,
+                    headers: mergedHeaders,
+                    timeout,
+                    retry,
+                    searchParams: filteredQuery,
+                };
+                if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+                    kyOptions.json = body;
+                }
+                const response = await self.client(url, kyOptions);
+                const data = await response.json();
+                return {
+                    data,
+                    status: response.status,
+                    headers: response.headers,
+                };
+            };
+            // 根据缓存模式执行
+            yield* self.executeWithCacheStrategy(finalCacheConfig.mode, cacheKey, finalCacheConfig.ttl, doRequest, cacheKeyRequest);
+        });
+    }
+    /**
+     * 根据缓存策略执行请求
+     */
+    async *executeWithCacheStrategy(mode, cacheKey, ttl, fetchFn, request) {
+        switch (mode) {
+            case CacheMode.OnlyRemote:
+                yield* this.strategyOnlyRemote(cacheKey, ttl, fetchFn, request);
+                break;
+            case CacheMode.OnlyCache:
+                yield* this.strategyOnlyCache(cacheKey);
+                break;
+            case CacheMode.IfCache:
+                yield* this.strategyIfCache(cacheKey, ttl, fetchFn, request);
+                break;
+            case CacheMode.FirstRemote:
+                yield* this.strategyFirstRemote(cacheKey, ttl, fetchFn, request);
+                break;
+            case CacheMode.FirstCache:
+                yield* this.strategyFirstCache(cacheKey, ttl, fetchFn, request);
+                break;
+            case CacheMode.LastCache:
+                yield* this.strategyLastCache(cacheKey, ttl, fetchFn, request);
+                break;
+            default:
+                yield* this.strategyOnlyRemote(cacheKey, ttl, fetchFn, request);
+        }
+    }
+    /**
+     * 判断响应是否应该缓存
+     *
+     * 调用全局缓存拦截器，根据响应内容决定是否缓存。
+     * 如果没有配置拦截器，默认允许缓存。
+     *
+     * @param result 请求响应结果
+     * @param cacheKey 缓存 key
+     * @param request 请求信息
+     * @param defaultTtl 默认 TTL
+     * @returns 是否缓存及最终 TTL
+     */
+    async shouldCacheResponse(result, cacheKey, request, defaultTtl) {
+        var _a;
+        // 没有配置拦截器，默认允许缓存
+        if (!this.config.cacheInterceptor) {
+            return { shouldCache: true, ttl: defaultTtl };
+        }
+        // 构建拦截器上下文
+        const context = {
+            data: result.data,
+            status: result.status,
+            headers: result.headers,
+            request,
+            cacheKey,
+        };
+        try {
+            // 调用拦截器（支持同步和异步）
+            const interceptorResult = await this.config.cacheInterceptor(context);
+            // 处理返回结果
+            if (typeof interceptorResult === 'boolean') {
+                return { shouldCache: interceptorResult, ttl: defaultTtl };
+            }
+            return {
+                shouldCache: interceptorResult.shouldCache,
+                ttl: (_a = interceptorResult.ttl) !== null && _a !== void 0 ? _a : defaultTtl,
+            };
+        }
+        catch (error) {
+            // 拦截器执行出错，保守起见不缓存，但不影响正常响应
+            console.warn('[HttpClient] cacheInterceptor error:', error);
+            return { shouldCache: false, ttl: defaultTtl };
+        }
+    }
+    /**
+     * 条件缓存：根据拦截器结果决定是否写入缓存
+     */
+    async conditionalCache(result, cacheKey, request, defaultTtl) {
+        const { shouldCache, ttl } = await this.shouldCacheResponse(result, cacheKey, request, defaultTtl);
+        if (shouldCache) {
+            await this.cache.set(cacheKey, result.data, ttl);
+        }
+    }
+    /**
+     * OnlyRemote: 只从服务器拿
+     */
+    async *strategyOnlyRemote(cacheKey, ttl, fetchFn, request) {
+        const result = await fetchFn();
+        await this.conditionalCache(result, cacheKey, request, ttl);
+        yield { data: result.data, fromCache: false };
+    }
+    /**
+     * OnlyCache: 只从缓存拿
+     */
+    async *strategyOnlyCache(cacheKey) {
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+            yield { data: cached.data, fromCache: true };
+        }
+        // 没有缓存就不 yield（类似 Observable.empty()）
+    }
+    /**
+     * IfCache: 有缓存返回缓存，否则请求网络
+     */
+    async *strategyIfCache(cacheKey, ttl, fetchFn, request) {
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+            yield { data: cached.data, fromCache: true };
+            return;
+        }
+        const result = await fetchFn();
+        await this.conditionalCache(result, cacheKey, request, ttl);
+        yield { data: result.data, fromCache: false };
+    }
+    /**
+     * FirstRemote: 先从服务器获取，没网络则读缓存
+     */
+    async *strategyFirstRemote(cacheKey, ttl, fetchFn, request) {
+        try {
+            const result = await fetchFn();
+            await this.conditionalCache(result, cacheKey, request, ttl);
+            yield { data: result.data, fromCache: false };
+        }
+        catch (error) {
+            // 网络错误时尝试读取缓存
+            const cached = await this.cache.get(cacheKey);
+            if (cached) {
+                yield { data: cached.data, fromCache: true };
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * FirstCache: 先从本地缓存拿，然后从服务器拿，可能 yield 两次
+     */
+    async *strategyFirstCache(cacheKey, ttl, fetchFn, request) {
+        // 先尝试读取缓存
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+            yield { data: cached.data, fromCache: true };
+        }
+        // 请求网络
+        try {
+            const result = await fetchFn();
+            await this.conditionalCache(result, cacheKey, request, ttl);
+            yield { data: result.data, fromCache: false };
+        }
+        catch (error) {
+            // 如果已有缓存，网络错误可以忽略
+            if (!cached) {
+                throw error;
+            }
+            // 有缓存时，网络错误静默处理
+        }
+    }
+    /**
+     * LastCache: 读上次缓存，没有则返回网络并同步缓存；有缓存也会后台同步网络但不 yield
+     */
+    async *strategyLastCache(cacheKey, ttl, fetchFn, request) {
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+            // 有缓存，返回缓存，后台同步网络（不 yield）
+            yield { data: cached.data, fromCache: true };
+            // 后台静默更新（也会经过拦截器判断）
+            fetchFn()
+                .then((result) => this.conditionalCache(result, cacheKey, request, ttl))
+                .catch(() => {
+                /* 静默忽略错误 */
+            });
+        }
+        else {
+            // 无缓存，从网络获取
+            const result = await fetchFn();
+            await this.conditionalCache(result, cacheKey, request, ttl);
+            yield { data: result.data, fromCache: false };
+        }
+    }
+    /**
+     * 获取缓存实例（用于高级操作）
+     */
+    getCache() {
+        return this.cache;
+    }
+    /**
+     * 清空所有缓存
+     */
+    async clearCache() {
+        await this.cache.clear();
+    }
+}

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

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

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

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

package/dist/http/client/index.js

@@ -0,0 +1,2 @@
+export { HttpClient } from './HttpClient';
+export { ApiStream } from './ApiStream';

package/dist/http/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * HTTP 网络框架
+ *
+ * 基于 ky + idb-keyval，支持：
+ * - 内存 + 磁盘双层缓存
+ * - 6 种缓存模式
+ * - AsyncGenerator 流式响应
+ * - 类 Retrofit 的 API 定义方式
+ *
+ * @example
+ * ```ts
+ * import { ApiBuilder, CacheMode } from 'xxf_react/http'
+ *
+ * const userApi = ApiBuilder.create({
+ *   baseUrl: 'https://api.example.com',
+ * })
+ *   .get<User>('getUser', {
+ *     path: '/users/{id}',
+ *     cache: { mode: CacheMode.IfCache, ttl: 60000 },
+ *   })
+ *   .build()
+ *
+ * // 方式1: 简单 await
+ * const user = await userApi.getUser({ pathParams: { id: '123' } })
+ *
+ * // 方式2: for await 多次响应
+ * for await (const { data, fromCache } of userApi.getUser({ pathParams: { id: '123' } })) {
+ *   console.log(data, fromCache)
+ * }
+ *
+ * // 方式3: subscribe 安全消费
+ * await userApi.getUser({ pathParams: { id: '123' } }).subscribe({
+ *   onData: (data, fromCache) => console.log(data),
+ *   onError: (e) => console.error(e),
+ * })
+ * ```
+ */
+export { CacheMode, type CacheEntry, type ApiResult, type ApiCallback, type CacheConfig, type CacheKeyRequest, type HttpClientConfig, type RequestConfig, type ApiOptions, type DiskLruCacheConfig, type HttpCacheConfig, type CacheInterceptor, type CacheInterceptorContext, type CacheInterceptorResult, } from './types';
+export { DiskLruCache, HttpCache } from './cache';
+export { HttpClient, ApiStream } from './client';
+export { ApiBuilder, type ApiEndpoint, type ApiDefinition } from './api';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,EACH,SAAS,EACT,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAEpB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,GAC9B,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGjD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGhD,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,OAAO,CAAA"}

package/dist/http/index.js

@@ -0,0 +1,45 @@
+/**
+ * HTTP 网络框架
+ *
+ * 基于 ky + idb-keyval，支持：
+ * - 内存 + 磁盘双层缓存
+ * - 6 种缓存模式
+ * - AsyncGenerator 流式响应
+ * - 类 Retrofit 的 API 定义方式
+ *
+ * @example
+ * ```ts
+ * import { ApiBuilder, CacheMode } from 'xxf_react/http'
+ *
+ * const userApi = ApiBuilder.create({
+ *   baseUrl: 'https://api.example.com',
+ * })
+ *   .get<User>('getUser', {
+ *     path: '/users/{id}',
+ *     cache: { mode: CacheMode.IfCache, ttl: 60000 },
+ *   })
+ *   .build()
+ *
+ * // 方式1: 简单 await
+ * const user = await userApi.getUser({ pathParams: { id: '123' } })
+ *
+ * // 方式2: for await 多次响应
+ * for await (const { data, fromCache } of userApi.getUser({ pathParams: { id: '123' } })) {
+ *   console.log(data, fromCache)
+ * }
+ *
+ * // 方式3: subscribe 安全消费
+ * await userApi.getUser({ pathParams: { id: '123' } }).subscribe({
+ *   onData: (data, fromCache) => console.log(data),
+ *   onError: (e) => console.error(e),
+ * })
+ * ```
+ */
+// Types
+export { CacheMode, } from './types';
+// Cache
+export { DiskLruCache, HttpCache } from './cache';
+// Client
+export { HttpClient, ApiStream } from './client';
+// API
+export { ApiBuilder } from './api';

package/dist/http/models/ApiTypes.d.ts

@@ -0,0 +1,54 @@
+/**
+ * API 响应相关类型
+ */
+/**
+ * API 响应结果
+ *
+ * 包含响应数据和来源标识
+ *
+ * @template T 响应数据类型
+ *
+ * @example
+ * ```ts
+ * for await (const result of api.getUser({ pathParams: { id: '1' } })) {
+ *   if (result.fromCache) {
+ *     showSkeleton(result.data)
+ *   } else {
+ *     renderFull(result.data)
+ *   }
+ * }
+ * ```
+ */
+export interface ApiResult<T> {
+    /** 响应数据 */
+    data: T;
+    /** 是否来自缓存 */
+    fromCache: boolean;
+}
+/**
+ * API 回调配置
+ *
+ * 用于 subscribe 安全消费模式，确保回调错误不影响后续响应
+ *
+ * @template T 响应数据类型
+ *
+ * @example
+ * ```ts
+ * await api.getUser({ pathParams: { id: '1' } }).subscribe({
+ *   onData: (data, fromCache) => {
+ *     renderUI(data)  // 即使这里抛错，网络数据仍会返回
+ *   },
+ *   onError: (e) => console.error(e),
+ *   onComplete: () => console.log('done'),
+ * })
+ * ```
+ */
+export interface ApiCallback<T> {
+    /** 数据回调 (可能多次调用) */
+    onData: (data: T, fromCache: boolean) => void;
+    /** 错误回调 */
+    onError?: (error: Error) => void;
+    /** 完成回调 */
+    onComplete?: () => void;
+}
+//# sourceMappingURL=ApiTypes.d.ts.map

package/dist/http/models/ApiTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiTypes.d.ts","sourceRoot":"","sources":["../../../src/http/models/ApiTypes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IACxB,WAAW;IACX,IAAI,EAAE,CAAC,CAAA;IACP,aAAa;IACb,SAAS,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC1B,oBAAoB;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C,WAAW;IACX,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAChC,WAAW;IACX,UAAU,CAAC,EAAE,MAAM,IAAI,CAAA;CAC1B"}

package/dist/http/models/ApiTypes.js

@@ -0,0 +1,4 @@
+/**
+ * API 响应相关类型
+ */
+export {};

package/dist/http/models/CacheConfig.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 缓存配置相关类型
+ */
+import { CacheMode } from './CacheMode';
+/**
+ * 缓存 key 计算请求参数
+ *
+ * 用于自定义缓存 key 生成函数
+ *
+ * @example
+ * ```ts
+ * cache: {
+ *   cacheKey: (req: CacheKeyRequest) => `user:${req.pathParams?.id}`,
+ * }
+ * ```
+ */
+export interface CacheKeyRequest {
+    /** 请求方法 */
+    method: string;
+    /** 请求路径 */
+    path: string;
+    /** 查询参数 */
+    query?: Record<string, unknown>;
+    /** 请求体 */
+    body?: unknown;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 路径参数 */
+    pathParams?: Record<string, string | number>;
+}
+/**
+ * 缓存配置
+ *
+ * 用于配置单个 API 的缓存行为
+ *
+ * @example
+ * ```ts
+ * .get<User>('getUser', {
+ *   path: '/users/{id}',
+ *   cache: {
+ *     mode: CacheMode.FirstCache,
+ *     ttl: 5 * 60 * 1000,  // 5 分钟
+ *     keyHeaders: ['Authorization'],
+ *   },
+ * })
+ * ```
+ */
+export interface CacheConfig {
+    /** 缓存模式 */
+    mode: CacheMode;
+    /** 缓存时间 (ms)，默认 5 分钟 */
+    ttl?: number;
+    /** 参与缓存 key 计算的 header 名称 */
+    keyHeaders?: string[];
+    /** 自定义缓存 key 生成函数 */
+    cacheKey?: (request: CacheKeyRequest) => string;
+}
+//# sourceMappingURL=CacheConfig.d.ts.map

package/dist/http/models/CacheConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheConfig.d.ts","sourceRoot":"","sources":["../../../src/http/models/CacheConfig.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC5B,WAAW;IACX,MAAM,EAAE,MAAM,CAAA;IACd,WAAW;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW;IACX,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,UAAU;IACV,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,UAAU;IACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,WAAW;IACX,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;CAC/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,WAAW;IACxB,WAAW;IACX,IAAI,EAAE,SAAS,CAAA;IACf,wBAAwB;IACxB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,qBAAqB;IACrB,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,MAAM,CAAA;CAClD"}

package/dist/http/models/CacheConfig.js

@@ -0,0 +1,4 @@
+/**
+ * 缓存配置相关类型
+ */
+export {};

package/dist/http/models/CacheEntry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 缓存条目
+ *
+ * 存储在内存缓存和磁盘缓存中的数据结构
+ *
+ * @template T 缓存数据类型
+ *
+ * @example
+ * ```ts
+ * const entry: CacheEntry<User> = {
+ *   data: { id: '1', name: 'John' },
+ *   timestamp: Date.now(),
+ *   ttl: 5 * 60 * 1000,  // 5 分钟
+ *   key: 'GET:/users/1',
+ * }
+ * ```
+ */
+export interface CacheEntry<T = unknown> {
+    /** 缓存数据 */
+    data: T;
+    /** 缓存时间戳 (ms) */
+    timestamp: number;
+    /** 过期时间 (ms)，0 表示永不过期 */
+    ttl: number;
+    /** 缓存 key */
+    key: string;
+}
+//# sourceMappingURL=CacheEntry.d.ts.map

package/dist/http/models/CacheEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheEntry.d.ts","sourceRoot":"","sources":["../../../src/http/models/CacheEntry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACnC,WAAW;IACX,IAAI,EAAE,CAAC,CAAA;IACP,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,aAAa;IACb,GAAG,EAAE,MAAM,CAAA;CACd"}

package/dist/http/models/CacheEntry.js

@@ -0,0 +1 @@
+export {};