@taicode/common-web 1.1.2 → 1.1.3

package/output/cache-api/cache-api.d.ts

@@ -2,12 +2,18 @@ type ApiFunc<P extends unknown[], R = unknown> = (...args: P) => Promise<R>;
 export declare class CacheApi<P extends unknown[], R> {
     private func;
     private cache;
+    private lastArgs;
     private accessor pendingRequests;
     constructor(func: ApiFunc<P, R>);
     get loading(): boolean;
     get empty(): boolean;
     get value(): R | undefined;
-    send(...args: P): Promise<R>;
+    call(...args: P): Promise<R>;
+    /**
+     * 使用最近一次的参数刷新数据
+     * @param force 强制刷新，清除缓存
+     */
+    refresh(force?: boolean): Promise<R>;
 }
 export {};
 //# sourceMappingURL=cache-api.d.ts.map

package/output/cache-api/cache-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache-api.d.ts","sourceRoot":"","sources":["../../source/cache-api/cache-api.ts"],"names":[],"mappings":"AAKA,KAAK,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAE3E,qBAAa,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC;IAO9B,OAAO,CAAC,IAAI;IANxB,OAAO,CAAC,KAAK,CAAqB;IAIlC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAI;gBAEhB,IAAI,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAIvC,IACI,OAAO,IAAI,OAAO,CAErB;IAED,IACI,KAAK,IAAI,OAAO,CAEnB;IAED,IACI,KAAK,IAAI,CAAC,GAAG,SAAS,CAEzB;IAGK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAmBnC"}
+{"version":3,"file":"cache-api.d.ts","sourceRoot":"","sources":["../../source/cache-api/cache-api.ts"],"names":[],"mappings":"AAKA,KAAK,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAE3E,qBAAa,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC;IAU9B,OAAO,CAAC,IAAI;IATxB,OAAO,CAAC,KAAK,CAAqB;IAGlC,OAAO,CAAC,QAAQ,CAAe;IAI/B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAI;gBAEhB,IAAI,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAIvC,IACI,OAAO,IAAI,OAAO,CAErB;IAED,IACI,KAAK,IAAI,OAAO,CAEnB;IAED,IACI,KAAK,IAAI,CAAC,GAAG,SAAS,CAEzB;IAGK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAuBlC;;;OAGG;IAEG,OAAO,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,CAAC,CAAC;CAalD"}

package/output/cache-api/cache-api.js

@@ -48,7 +48,7 @@ import { catchIt } from '@taicode/common-base';
 import { SideCache } from '../side-cache';
 let CacheApi = (() => {
     var _a, _CacheApi_pendingRequests_accessor_storage;
-    var _b;
+    var _b, _c;
     let _instanceExtraInitializers = [];
     let _pendingRequests_decorators;
     let _pendingRequests_initializers = [];
@@ -56,7 +56,8 @@ let CacheApi = (() => {
     let _get_loading_decorators;
     let _get_empty_decorators;
     let _get_value_decorators;
-    let _send_decorators;
+    let _call_decorators;
+    let _refresh_decorators;
     return _a = class CacheApi {
             // 记录当前正在进行的请求数量
             get pendingRequests() { return __classPrivateFieldGet(this, _CacheApi_pendingRequests_accessor_storage, "f"); }
@@ -67,7 +68,7 @@ let CacheApi = (() => {
                 _CacheApi_pendingRequests_accessor_storage.set(this, __runInitializers(this, _pendingRequests_initializers, 0));
                 __runInitializers(this, _pendingRequests_extraInitializers);
                 this.func = func;
-                this.send = this.send.bind(this);
+                this.call = this.call.bind(this);
             }
             get loading() {
                 return this.pendingRequests > 0;
@@ -78,7 +79,9 @@ let CacheApi = (() => {
             get value() {
                 return this.cache.value;
             }
-            async send(...args) {
+            async call(...args) {
+                // 记录最近一次调用的参数
+                this.lastArgs = args;
                 // 增加待处理请求计数
                 this.pendingRequests++;
                 const result = await catchIt(async () => {
@@ -93,6 +96,21 @@ let CacheApi = (() => {
                 }
                 return result.value;
             }
+            /**
+             * 使用最近一次的参数刷新数据
+             * @param force 强制刷新，清除缓存
+             */
+            async refresh(force = false) {
+                if (this.lastArgs === undefined) {
+                    throw new Error('没有可用的参数来刷新数据，请先调用 call 方法');
+                }
+                if (force) {
+                    // 强制刷新，先清除缓存
+                    this.cache.clear(this.lastArgs);
+                }
+                // 重新调用最近一次的参数
+                return await this.call(...this.lastArgs);
+            }
         },
         _CacheApi_pendingRequests_accessor_storage = new WeakMap(),
         (() => {
@@ -101,12 +119,14 @@ let CacheApi = (() => {
             _get_loading_decorators = [computed];
             _get_empty_decorators = [computed];
             _get_value_decorators = [computed];
-            _send_decorators = [(_b = action).bound.bind(_b)];
+            _call_decorators = [(_b = action).bound.bind(_b)];
+            _refresh_decorators = [(_c = action).bound.bind(_c)];
             __esDecorate(_a, null, _pendingRequests_decorators, { kind: "accessor", name: "pendingRequests", static: false, private: false, access: { has: obj => "pendingRequests" in obj, get: obj => obj.pendingRequests, set: (obj, value) => { obj.pendingRequests = value; } }, metadata: _metadata }, _pendingRequests_initializers, _pendingRequests_extraInitializers);
             __esDecorate(_a, null, _get_loading_decorators, { kind: "getter", name: "loading", static: false, private: false, access: { has: obj => "loading" in obj, get: obj => obj.loading }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _get_empty_decorators, { kind: "getter", name: "empty", static: false, private: false, access: { has: obj => "empty" in obj, get: obj => obj.empty }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _get_value_decorators, { kind: "getter", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _send_decorators, { kind: "method", name: "send", static: false, private: false, access: { has: obj => "send" in obj, get: obj => obj.send }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _call_decorators, { kind: "method", name: "call", static: false, private: false, access: { has: obj => "call" in obj, get: obj => obj.call }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _refresh_decorators, { kind: "method", name: "refresh", static: false, private: false, access: { has: obj => "refresh" in obj, get: obj => obj.refresh }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         })(),
         _a;

package/output/cache-api/cache-api.test.js

@@ -25,7 +25,7 @@ describe('CacheApi', () => {
             expect(cacheApi.value).toBeUndefined();
         });
         it('应该正确绑定 send 方法', () => {
-            const { send } = cacheApi;
+            const { call: send } = cacheApi;
             expect(typeof send).toBe('function');
         });
     });
@@ -36,17 +36,17 @@ describe('CacheApi', () => {
         it('应该在成功调用后返回缓存的值', async () => {
             const expectedResult = 'test-result';
             mockApiFunc.mockResolvedValue(expectedResult);
-            await cacheApi.send('param1', 123);
+            await cacheApi.call('param1', 123);
             expect(cacheApi.value).toBe(expectedResult);
         });
         it('应该在多次调用后返回最新的缓存值', async () => {
             const result1 = 'result-1';
             const result2 = 'result-2';
             mockApiFunc.mockResolvedValueOnce(result1);
-            await cacheApi.send('param1', 123);
+            await cacheApi.call('param1', 123);
             expect(cacheApi.value).toBe(result1);
             mockApiFunc.mockResolvedValueOnce(result2);
-            await cacheApi.send('param2', 456);
+            await cacheApi.call('param2', 456);
             expect(cacheApi.value).toBe(result2);
         });
     });
@@ -56,14 +56,14 @@ describe('CacheApi', () => {
         });
         it('成功调用后应该返回 false', async () => {
             mockApiFunc.mockResolvedValue('test-result');
-            await cacheApi.send('param1', 123);
+            await cacheApi.call('param1', 123);
             expect(cacheApi.empty).toBe(false);
         });
         it('即使调用失败也应该保持 true', async () => {
             const error = new Error('API Error');
             mockApiFunc.mockRejectedValue(error);
             try {
-                await cacheApi.send('param1', 123);
+                await cacheApi.call('param1', 123);
             }
             catch (e) {
                 // 忽略错误
@@ -81,7 +81,7 @@ describe('CacheApi', () => {
         it('应该调用传入的 API 函数', async () => {
             const expectedResult = 'api-result';
             mockApiFunc.mockResolvedValue(expectedResult);
-            const result = await cacheApi.send('test', 42);
+            const result = await cacheApi.call('test', 42);
             expect(mockApiFunc).toHaveBeenCalledTimes(1);
             expect(mockApiFunc).toHaveBeenCalledWith('test', 42);
             expect(result).toBe(expectedResult);
@@ -89,19 +89,19 @@ describe('CacheApi', () => {
         it('应该正确传递多个参数', async () => {
             const params = ['hello', 999];
             mockApiFunc.mockResolvedValue('success');
-            await cacheApi.send(...params);
+            await cacheApi.call(...params);
             expect(mockApiFunc).toHaveBeenCalledWith(...params);
         });
         it('应该返回 API 函数的结果', async () => {
             const expectedResult = { data: 'test', status: 'ok' };
             mockApiFunc.mockResolvedValue(expectedResult);
-            const result = await cacheApi.send('param', 1);
+            const result = await cacheApi.call('param', 1);
             expect(result).toEqual(expectedResult);
         });
         it('应该处理 API 函数抛出的异常', async () => {
             const error = new Error('API Error');
             mockApiFunc.mockRejectedValue(error);
-            await expect(cacheApi.send('param', 1)).rejects.toThrow('API Error');
+            await expect(cacheApi.call('param', 1)).rejects.toThrow('API Error');
         });
     });
     describe('缓存功能', () => {
@@ -109,11 +109,11 @@ describe('CacheApi', () => {
             const result = 'cached-result';
             mockApiFunc.mockResolvedValue(result);
             // 第一次调用
-            const firstResult = await cacheApi.send('same', 123);
+            const firstResult = await cacheApi.call('same', 123);
             expect(firstResult).toBe(result);
             expect(cacheApi.value).toBe(result);
             // 第二次调用相同参数，应该从缓存返回
-            const secondResult = await cacheApi.send('same', 123);
+            const secondResult = await cacheApi.call('same', 123);
             expect(secondResult).toBe(result);
             expect(cacheApi.value).toBe(result);
             // API 函数应该被调用两次（SideCache 的 handle 方法会每次都调用）
@@ -122,8 +122,8 @@ describe('CacheApi', () => {
         it('不同参数应该触发新的 API 调用', async () => {
             mockApiFunc.mockResolvedValueOnce('result1');
             mockApiFunc.mockResolvedValueOnce('result2');
-            await cacheApi.send('param1', 1);
-            await cacheApi.send('param2', 2);
+            await cacheApi.call('param1', 1);
+            await cacheApi.call('param2', 2);
             expect(mockApiFunc).toHaveBeenCalledTimes(2);
             expect(mockApiFunc).toHaveBeenNthCalledWith(1, 'param1', 1);
             expect(mockApiFunc).toHaveBeenNthCalledWith(2, 'param2', 2);
@@ -131,9 +131,9 @@ describe('CacheApi', () => {
         it('应该正确更新当前缓存的 key', async () => {
             mockApiFunc.mockResolvedValueOnce('value1');
             mockApiFunc.mockResolvedValueOnce('value2');
-            await cacheApi.send('key1', 1);
+            await cacheApi.call('key1', 1);
             expect(cacheApi.value).toBe('value1');
-            await cacheApi.send('key2', 2);
+            await cacheApi.call('key2', 2);
             expect(cacheApi.value).toBe('value2');
         });
     });
@@ -145,9 +145,9 @@ describe('CacheApi', () => {
                 return `result-${param}-${++resolveCount}`;
             });
             const [result1, result2, result3] = await Promise.all([
-                cacheApi.send('param1', 1),
-                cacheApi.send('param2', 2),
-                cacheApi.send('param3', 3)
+                cacheApi.call('param1', 1),
+                cacheApi.call('param2', 2),
+                cacheApi.call('param3', 3)
             ]);
             expect(result1).toMatch(/result-param1-\d/);
             expect(result2).toMatch(/result-param2-\d/);
@@ -161,7 +161,7 @@ describe('CacheApi', () => {
                 return 'delayed-result';
             });
             // 开始异步操作，此时 value 应该还是之前的值
-            const promise = cacheApi.send('test', 1);
+            const promise = cacheApi.call('test', 1);
             // 等待一小段时间，但还没完成
             await new Promise(resolve => setTimeout(resolve, delay / 2));
             // 完成异步操作
@@ -173,13 +173,13 @@ describe('CacheApi', () => {
     describe('边缘情况', () => {
         it('应该处理 null 返回值', async () => {
             mockApiFunc.mockResolvedValue(null);
-            const result = await cacheApi.send('test', 1);
+            const result = await cacheApi.call('test', 1);
             expect(result).toBeNull();
             expect(cacheApi.value).toBeNull();
         });
         it('应该处理 undefined 返回值', async () => {
             mockApiFunc.mockResolvedValue(undefined);
-            const result = await cacheApi.send('test', 1);
+            const result = await cacheApi.call('test', 1);
             expect(result).toBeUndefined();
             expect(cacheApi.value).toBeUndefined();
         });
@@ -189,13 +189,13 @@ describe('CacheApi', () => {
             complexMockFunc.mockResolvedValue('complex-result');
             // 创建一个接受复杂参数的 CacheApi
             const complexCacheApi = new CacheApi(complexMockFunc);
-            const result = await complexCacheApi.send(complexParam);
+            const result = await complexCacheApi.call(complexParam);
             expect(result).toBe('complex-result');
             expect(complexMockFunc).toHaveBeenCalledWith(complexParam);
         });
         it('should handle no parameters', async () => {
             const noParamApi = new CacheApi(() => Promise.resolve('no-param-result'));
-            const result = await noParamApi.send();
+            const result = await noParamApi.call();
             expect(result).toBe('no-param-result');
         });
     });
@@ -221,7 +221,7 @@ describe('CacheApi', () => {
                 return reaction;
             });
             mockApiFunc.mockResolvedValue('new-value');
-            await cacheApi.send('test', 1);
+            await cacheApi.call('test', 1);
             // 清理
             if (typeof disposer === 'function') {
                 disposer();
@@ -237,7 +237,7 @@ describe('CacheApi', () => {
                 return Promise.resolve({ result: `${str}-${num}-${bool}` });
             });
             // 正确的调用
-            expect(() => typedApi.send('test', 42, true)).not.toThrow();
+            expect(() => typedApi.call('test', 42, true)).not.toThrow();
             // 以下调用在 TypeScript 中会产生编译错误（在运行时测试中跳过）
             // typedApi.send('test', 'wrong-type', true)  // 第二个参数应该是 number
             // typedApi.send('test', 42)  // 缺少第三个参数
@@ -254,7 +254,7 @@ describe('CacheApi', () => {
             });
             mockApiFunc.mockReturnValue(promise);
             // 开始请求
-            const sendPromise = cacheApi.send('test', 1);
+            const sendPromise = cacheApi.call('test', 1);
             // 此时应该是 loading 状态
             expect(cacheApi.loading).toBe(true);
             // 完成请求
@@ -267,7 +267,7 @@ describe('CacheApi', () => {
             const error = new Error('API Error');
             mockApiFunc.mockRejectedValue(error);
             try {
-                await cacheApi.send('test', 1);
+                await cacheApi.call('test', 1);
             }
             catch (e) {
                 // 忽略错误
@@ -282,9 +282,9 @@ describe('CacheApi', () => {
                 });
             });
             // 启动三个并发请求
-            const promise1 = cacheApi.send('req1', 1);
-            const promise2 = cacheApi.send('req2', 2);
-            const promise3 = cacheApi.send('req3', 3);
+            const promise1 = cacheApi.call('req1', 1);
+            const promise2 = cacheApi.call('req2', 2);
+            const promise3 = cacheApi.call('req3', 3);
             // 此时应该有三个请求正在进行，loading 为 true
             expect(cacheApi.loading).toBe(true);
             // 完成第一个请求
@@ -319,8 +319,8 @@ describe('CacheApi', () => {
                 }
             });
             // 启动两个请求，一个成功一个失败
-            const successPromise = cacheApi.send('success', 1);
-            const errorPromise = cacheApi.send('error', 2);
+            const successPromise = cacheApi.call('success', 1);
+            const errorPromise = cacheApi.call('error', 2);
             expect(cacheApi.loading).toBe(true);
             // 先让失败的请求完成
             rejectError(new Error('Failed'));
@@ -345,4 +345,105 @@ describe('CacheApi', () => {
             expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.set).toBeUndefined();
         });
     });
+    describe('refresh 方法', () => {
+        it('应该在没有调用过 call 时抛出错误', async () => {
+            await expect(cacheApi.refresh()).rejects.toThrow('没有可用的参数来刷新数据，请先调用 call 方法');
+        });
+        it('应该使用最近一次的参数重新调用 API', async () => {
+            const expectedResult1 = 'first-result';
+            const expectedResult2 = 'refreshed-result';
+            mockApiFunc.mockResolvedValueOnce(expectedResult1);
+            mockApiFunc.mockResolvedValueOnce(expectedResult2);
+            // 第一次调用
+            await cacheApi.call('param1', 123);
+            expect(cacheApi.value).toBe(expectedResult1);
+            expect(mockApiFunc).toHaveBeenCalledTimes(1);
+            expect(mockApiFunc).toHaveBeenCalledWith('param1', 123);
+            // 刷新
+            const refreshResult = await cacheApi.refresh();
+            expect(refreshResult).toBe(expectedResult2);
+            expect(cacheApi.value).toBe(expectedResult2);
+            expect(mockApiFunc).toHaveBeenCalledTimes(2);
+            expect(mockApiFunc).toHaveBeenNthCalledWith(2, 'param1', 123);
+        });
+        it('应该在多次调用后使用最新的参数进行刷新', async () => {
+            mockApiFunc.mockResolvedValue('result');
+            // 第一次调用
+            await cacheApi.call('param1', 123);
+            // 第二次调用，参数不同
+            await cacheApi.call('param2', 456);
+            // 刷新应该使用最新的参数
+            await cacheApi.refresh();
+            expect(mockApiFunc).toHaveBeenCalledTimes(3);
+            expect(mockApiFunc).toHaveBeenNthCalledWith(3, 'param2', 456);
+        });
+        it('应该在 force=false 时正常刷新（默认行为）', async () => {
+            const result1 = 'cached-result';
+            const result2 = 'refreshed-result';
+            mockApiFunc.mockResolvedValueOnce(result1);
+            mockApiFunc.mockResolvedValueOnce(result2);
+            await cacheApi.call('test', 1);
+            const refreshResult = await cacheApi.refresh(false);
+            expect(refreshResult).toBe(result2);
+            expect(mockApiFunc).toHaveBeenCalledTimes(2);
+        });
+        it('应该在 force=true 时强制刷新并清除缓存', async () => {
+            const result1 = 'cached-result';
+            const result2 = 'force-refreshed-result';
+            mockApiFunc.mockResolvedValueOnce(result1);
+            mockApiFunc.mockResolvedValueOnce(result2);
+            await cacheApi.call('test', 1);
+            const refreshResult = await cacheApi.refresh(true);
+            expect(refreshResult).toBe(result2);
+            expect(mockApiFunc).toHaveBeenCalledTimes(2);
+        });
+        it('应该正确处理刷新时的异常', async () => {
+            const error = new Error('Refresh failed');
+            mockApiFunc.mockResolvedValueOnce('initial-result');
+            mockApiFunc.mockRejectedValueOnce(error);
+            // 第一次调用成功
+            await cacheApi.call('test', 1);
+            expect(cacheApi.value).toBe('initial-result');
+            // 刷新时失败
+            await expect(cacheApi.refresh()).rejects.toThrow('Refresh failed');
+            // 值应该保持不变
+            expect(cacheApi.value).toBe('initial-result');
+        });
+        it('应该在刷新期间正确更新 loading 状态', async () => {
+            let resolveFn;
+            const promise = new Promise((resolve) => {
+                resolveFn = resolve;
+            });
+            mockApiFunc.mockResolvedValueOnce('initial');
+            mockApiFunc.mockReturnValueOnce(promise);
+            // 初始调用
+            await cacheApi.call('test', 1);
+            expect(cacheApi.loading).toBe(false);
+            // 开始刷新
+            const refreshPromise = cacheApi.refresh();
+            expect(cacheApi.loading).toBe(true);
+            // 完成刷新
+            resolveFn('refreshed');
+            await refreshPromise;
+            expect(cacheApi.loading).toBe(false);
+        });
+        it('应该正确处理复杂参数的刷新', async () => {
+            const complexParam = { id: 1, data: { nested: 'value' } };
+            const complexMockFunc = vi.fn();
+            complexMockFunc.mockResolvedValue('complex-result');
+            const complexCacheApi = new CacheApi(complexMockFunc);
+            await complexCacheApi.call(complexParam);
+            await complexCacheApi.refresh();
+            expect(complexMockFunc).toHaveBeenCalledTimes(2);
+            expect(complexMockFunc).toHaveBeenNthCalledWith(2, complexParam);
+        });
+        it('应该支持无参数函数的刷新', async () => {
+            const noParamMockFunc = vi.fn();
+            noParamMockFunc.mockResolvedValue('no-param-result');
+            const noParamCacheApi = new CacheApi(noParamMockFunc);
+            await noParamCacheApi.call();
+            await noParamCacheApi.refresh();
+            expect(noParamMockFunc).toHaveBeenCalledTimes(2);
+        });
+    });
 });

package/output/side-cache/side-cache.d.ts

@@ -6,5 +6,6 @@ export declare class SideCache<T> {
     get empty(): boolean;
     handle<F extends ((...args: unknown[]) => T)>(key: unknown, func: F): T;
     handle<F extends ((...args: unknown[]) => Promise<T> | T)>(key: unknown, func: F): Promise<T> | T;
+    clear(key?: unknown): void;
 }
 //# sourceMappingURL=side-cache.d.ts.map

package/output/side-cache/side-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"side-cache.d.ts","sourceRoot":"","sources":["../../source/side-cache/side-cache.ts"],"names":[],"mappings":"AAWA,qBAAa,SAAS,CAAC,CAAC;IAEtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAG1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAG/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAE1D,IACW,KAAK,IAAI,CAAC,GAAG,SAAS,CAIhC;IAED,IACW,KAAK,IAAI,OAAO,CAE1B;IAED,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IACvE,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;CAuClG"}
+{"version":3,"file":"side-cache.d.ts","sourceRoot":"","sources":["../../source/side-cache/side-cache.ts"],"names":[],"mappings":"AAWA,qBAAa,SAAS,CAAC,CAAC;IAEtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAG1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAG/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAE1D,IACW,KAAK,IAAI,CAAC,GAAG,SAAS,CAIhC;IAED,IACW,KAAK,IAAI,OAAO,CAE1B;IAED,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IACvE,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;IAyC1F,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,GAAG,IAAI;CAoBlC"}

package/output/side-cache/side-cache.js

@@ -49,7 +49,7 @@ function isPromiseLike(value) {
 }
 let SideCache = (() => {
     var _a, _SideCache_emptyFlag_accessor_storage, _SideCache_currentKey_accessor_storage, _SideCache_cache_accessor_storage;
-    var _b, _c;
+    var _b, _c, _d;
     let _instanceExtraInitializers = [];
     let _emptyFlag_decorators;
     let _emptyFlag_initializers = [];
@@ -63,6 +63,7 @@ let SideCache = (() => {
     let _get_value_decorators;
     let _get_empty_decorators;
     let _handle_decorators;
+    let _clear_decorators;
     return _a = class SideCache {
             get emptyFlag() { return __classPrivateFieldGet(this, _SideCache_emptyFlag_accessor_storage, "f"); }
             set emptyFlag(value) { __classPrivateFieldSet(this, _SideCache_emptyFlag_accessor_storage, value, "f"); }
@@ -106,6 +107,27 @@ let SideCache = (() => {
                 });
                 return funcReturn;
             }
+            clear(key) {
+                var _b;
+                if (key === undefined) {
+                    // 清除所有缓存
+                    this.cache = {};
+                    this.emptyFlag = true;
+                    this.currentKey = undefined;
+                }
+                else {
+                    // 清除指定 key 的缓存
+                    const keyStringify = (_b = JSON.stringify(key)) !== null && _b !== void 0 ? _b : 'undefined';
+                    const newCache = Object.assign({}, this.cache);
+                    delete newCache[keyStringify];
+                    this.cache = newCache;
+                    // 如果清除的是当前 key，需要重置状态
+                    if (this.currentKey === keyStringify) {
+                        this.emptyFlag = Object.keys(this.cache).length === 0;
+                        this.currentKey = undefined;
+                    }
+                }
+            }
             constructor() {
                 _SideCache_emptyFlag_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _emptyFlag_initializers, true)));
                 _SideCache_currentKey_accessor_storage.set(this, (__runInitializers(this, _emptyFlag_extraInitializers), __runInitializers(this, _currentKey_initializers, void 0)));
@@ -124,12 +146,14 @@ let SideCache = (() => {
             _get_value_decorators = [computed];
             _get_empty_decorators = [computed];
             _handle_decorators = [(_c = action).bound.bind(_c)];
+            _clear_decorators = [(_d = action).bound.bind(_d)];
             __esDecorate(_a, null, _emptyFlag_decorators, { kind: "accessor", name: "emptyFlag", static: false, private: false, access: { has: obj => "emptyFlag" in obj, get: obj => obj.emptyFlag, set: (obj, value) => { obj.emptyFlag = value; } }, metadata: _metadata }, _emptyFlag_initializers, _emptyFlag_extraInitializers);
             __esDecorate(_a, null, _currentKey_decorators, { kind: "accessor", name: "currentKey", static: false, private: false, access: { has: obj => "currentKey" in obj, get: obj => obj.currentKey, set: (obj, value) => { obj.currentKey = value; } }, metadata: _metadata }, _currentKey_initializers, _currentKey_extraInitializers);
             __esDecorate(_a, null, _cache_decorators, { kind: "accessor", name: "cache", static: false, private: false, access: { has: obj => "cache" in obj, get: obj => obj.cache, set: (obj, value) => { obj.cache = value; } }, metadata: _metadata }, _cache_initializers, _cache_extraInitializers);
             __esDecorate(_a, null, _get_value_decorators, { kind: "getter", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _get_empty_decorators, { kind: "getter", name: "empty", static: false, private: false, access: { has: obj => "empty" in obj, get: obj => obj.empty }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _handle_decorators, { kind: "method", name: "handle", static: false, private: false, access: { has: obj => "handle" in obj, get: obj => obj.handle }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _clear_decorators, { kind: "method", name: "clear", static: false, private: false, access: { has: obj => "clear" in obj, get: obj => obj.clear }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         })(),
         _a;

package/output/side-cache/side-cache.test.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runInAction } from 'mobx';
 import { SideCache } from './side-cache';
 describe('SideCache', () => {
     let cache;
@@ -176,4 +177,95 @@ describe('SideCache', () => {
             }
         });
     });
+    describe('clear 方法', () => {
+        it('应该能够清除指定 key 的缓存', () => {
+            const mockFunc = vi.fn(() => 'test-result');
+            const key = 'test-key';
+            // 先添加缓存
+            cache.handle(key, mockFunc);
+            expect(cache.empty).toBe(false);
+            expect(cache.value).toBe('test-result');
+            // 清除指定 key 的缓存
+            cache.clear(key);
+            expect(cache.empty).toBe(true);
+            expect(cache.value).toBe(undefined);
+        });
+        it('应该能够清除当前激活的缓存', () => {
+            const mockFunc = vi.fn(() => 'active-result');
+            const key = 'active-key';
+            cache.handle(key, mockFunc);
+            expect(cache.value).toBe('active-result');
+            // 清除当前激活的 key
+            cache.clear(key);
+            expect(cache.value).toBe(undefined);
+            expect(cache.empty).toBe(true);
+        });
+        it('应该能够清除所有缓存', () => {
+            const mockFunc1 = vi.fn(() => 'result1');
+            const mockFunc2 = vi.fn(() => 'result2');
+            // 添加多个缓存
+            cache.handle('key1', mockFunc1);
+            cache.handle('key2', mockFunc2);
+            expect(cache.value).toBe('result2');
+            expect(cache.empty).toBe(false);
+            // 清除所有缓存
+            cache.clear();
+            expect(cache.value).toBe(undefined);
+            expect(cache.empty).toBe(true);
+        });
+        it('应该能够清除非当前激活的缓存而不影响当前状态', () => {
+            const mockFunc1 = vi.fn(() => 'result1');
+            const mockFunc2 = vi.fn(() => 'result2');
+            // 添加两个缓存
+            cache.handle('key1', mockFunc1);
+            cache.handle('key2', mockFunc2);
+            expect(cache.value).toBe('result2'); // 当前激活的是 key2
+            // 清除非当前激活的 key1
+            cache.clear('key1');
+            expect(cache.value).toBe('result2'); // 当前值不变
+            expect(cache.empty).toBe(false); // 仍有缓存存在
+        });
+        it('应该正确处理清除不存在的 key', () => {
+            const mockFunc = vi.fn(() => 'test-result');
+            cache.handle('existing-key', mockFunc);
+            // 清除不存在的 key 不应该影响现有缓存
+            cache.clear('non-existing-key');
+            expect(cache.value).toBe('test-result');
+            expect(cache.empty).toBe(false);
+        });
+        it('应该正确处理复杂对象作为 key', () => {
+            const complexKey = { id: 1, data: { nested: 'value' } };
+            const mockFunc = vi.fn(() => 'complex-result');
+            // 使用复杂对象作为 key
+            cache.handle(complexKey, mockFunc);
+            expect(cache.value).toBe('complex-result');
+            // 清除复杂对象 key
+            cache.clear(complexKey);
+            expect(cache.value).toBe(undefined);
+            expect(cache.empty).toBe(true);
+        });
+        it('应该正确处理 undefined 作为 key', () => {
+            const mockFunc = vi.fn(() => 'undefined-key-result');
+            // 使用 undefined 作为 key
+            cache.handle(undefined, mockFunc);
+            expect(cache.value).toBe('undefined-key-result');
+            // 清除 undefined key
+            cache.clear(undefined);
+            expect(cache.value).toBe(undefined);
+            expect(cache.empty).toBe(true);
+        });
+        it('应该在 MobX action 中正确更新状态', () => {
+            const mockFunc = vi.fn(() => 'action-result');
+            const key = 'action-key';
+            runInAction(() => {
+                cache.handle(key, mockFunc);
+            });
+            expect(cache.value).toBe('action-result');
+            runInAction(() => {
+                cache.clear(key);
+            });
+            expect(cache.value).toBe(undefined);
+            expect(cache.empty).toBe(true);
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-web",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "author": "Alain",
   "license": "ISC",
   "description": "",