@taicode/common-web 1.1.0 → 1.1.2

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

@@ -0,0 +1,348 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { runInAction, configure } from 'mobx';
+import { CacheApi } from './cache-api';
+// 配置 MobX 在测试环境中的行为
+configure({
+    enforceActions: 'never',
+    computedRequiresReaction: false,
+    reactionRequiresObservable: false,
+    observableRequiresReaction: false,
+    disableErrorBoundaries: true
+});
+describe('CacheApi', () => {
+    let mockApiFunc;
+    let cacheApi;
+    beforeEach(() => {
+        mockApiFunc = vi.fn();
+        cacheApi = new CacheApi(mockApiFunc);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('构造函数', () => {
+        it('应该正确初始化 CacheApi 实例', () => {
+            expect(cacheApi).toBeInstanceOf(CacheApi);
+            expect(cacheApi.value).toBeUndefined();
+        });
+        it('应该正确绑定 send 方法', () => {
+            const { send } = cacheApi;
+            expect(typeof send).toBe('function');
+        });
+    });
+    describe('value getter', () => {
+        it('初始状态下应该返回 undefined', () => {
+            expect(cacheApi.value).toBeUndefined();
+        });
+        it('应该在成功调用后返回缓存的值', async () => {
+            const expectedResult = 'test-result';
+            mockApiFunc.mockResolvedValue(expectedResult);
+            await cacheApi.send('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);
+            expect(cacheApi.value).toBe(result1);
+            mockApiFunc.mockResolvedValueOnce(result2);
+            await cacheApi.send('param2', 456);
+            expect(cacheApi.value).toBe(result2);
+        });
+    });
+    describe('empty getter', () => {
+        it('初始状态下应该返回 true', () => {
+            expect(cacheApi.empty).toBe(true);
+        });
+        it('成功调用后应该返回 false', async () => {
+            mockApiFunc.mockResolvedValue('test-result');
+            await cacheApi.send('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);
+            }
+            catch (e) {
+                // 忽略错误
+            }
+            expect(cacheApi.empty).toBe(true);
+        });
+        it('empty 应该是一个 computed 属性', () => {
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(cacheApi), 'empty');
+            expect(descriptor).toBeDefined();
+            expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.get).toBeDefined();
+            expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.set).toBeUndefined();
+        });
+    });
+    describe('send 方法', () => {
+        it('应该调用传入的 API 函数', async () => {
+            const expectedResult = 'api-result';
+            mockApiFunc.mockResolvedValue(expectedResult);
+            const result = await cacheApi.send('test', 42);
+            expect(mockApiFunc).toHaveBeenCalledTimes(1);
+            expect(mockApiFunc).toHaveBeenCalledWith('test', 42);
+            expect(result).toBe(expectedResult);
+        });
+        it('应该正确传递多个参数', async () => {
+            const params = ['hello', 999];
+            mockApiFunc.mockResolvedValue('success');
+            await cacheApi.send(...params);
+            expect(mockApiFunc).toHaveBeenCalledWith(...params);
+        });
+        it('应该返回 API 函数的结果', async () => {
+            const expectedResult = { data: 'test', status: 'ok' };
+            mockApiFunc.mockResolvedValue(expectedResult);
+            const result = await cacheApi.send('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');
+        });
+    });
+    describe('缓存功能', () => {
+        it('相同参数应该使用缓存', async () => {
+            const result = 'cached-result';
+            mockApiFunc.mockResolvedValue(result);
+            // 第一次调用
+            const firstResult = await cacheApi.send('same', 123);
+            expect(firstResult).toBe(result);
+            expect(cacheApi.value).toBe(result);
+            // 第二次调用相同参数，应该从缓存返回
+            const secondResult = await cacheApi.send('same', 123);
+            expect(secondResult).toBe(result);
+            expect(cacheApi.value).toBe(result);
+            // API 函数应该被调用两次（SideCache 的 handle 方法会每次都调用）
+            expect(mockApiFunc).toHaveBeenCalledTimes(2);
+        });
+        it('不同参数应该触发新的 API 调用', async () => {
+            mockApiFunc.mockResolvedValueOnce('result1');
+            mockApiFunc.mockResolvedValueOnce('result2');
+            await cacheApi.send('param1', 1);
+            await cacheApi.send('param2', 2);
+            expect(mockApiFunc).toHaveBeenCalledTimes(2);
+            expect(mockApiFunc).toHaveBeenNthCalledWith(1, 'param1', 1);
+            expect(mockApiFunc).toHaveBeenNthCalledWith(2, 'param2', 2);
+        });
+        it('应该正确更新当前缓存的 key', async () => {
+            mockApiFunc.mockResolvedValueOnce('value1');
+            mockApiFunc.mockResolvedValueOnce('value2');
+            await cacheApi.send('key1', 1);
+            expect(cacheApi.value).toBe('value1');
+            await cacheApi.send('key2', 2);
+            expect(cacheApi.value).toBe('value2');
+        });
+    });
+    describe('异步操作', () => {
+        it('应该正确处理并发调用', async () => {
+            let resolveCount = 0;
+            mockApiFunc.mockImplementation(async (param) => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+                return `result-${param}-${++resolveCount}`;
+            });
+            const [result1, result2, result3] = await Promise.all([
+                cacheApi.send('param1', 1),
+                cacheApi.send('param2', 2),
+                cacheApi.send('param3', 3)
+            ]);
+            expect(result1).toMatch(/result-param1-\d/);
+            expect(result2).toMatch(/result-param2-\d/);
+            expect(result3).toMatch(/result-param3-\d/);
+            expect(mockApiFunc).toHaveBeenCalledTimes(3);
+        });
+        it('应该在异步操作完成后更新 value', async () => {
+            const delay = 50;
+            mockApiFunc.mockImplementation(async () => {
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return 'delayed-result';
+            });
+            // 开始异步操作，此时 value 应该还是之前的值
+            const promise = cacheApi.send('test', 1);
+            // 等待一小段时间，但还没完成
+            await new Promise(resolve => setTimeout(resolve, delay / 2));
+            // 完成异步操作
+            const result = await promise;
+            expect(result).toBe('delayed-result');
+            expect(cacheApi.value).toBe('delayed-result');
+        });
+    });
+    describe('边缘情况', () => {
+        it('应该处理 null 返回值', async () => {
+            mockApiFunc.mockResolvedValue(null);
+            const result = await cacheApi.send('test', 1);
+            expect(result).toBeNull();
+            expect(cacheApi.value).toBeNull();
+        });
+        it('应该处理 undefined 返回值', async () => {
+            mockApiFunc.mockResolvedValue(undefined);
+            const result = await cacheApi.send('test', 1);
+            expect(result).toBeUndefined();
+            expect(cacheApi.value).toBeUndefined();
+        });
+        it('应该处理复杂对象参数', async () => {
+            const complexParam = { nested: { value: 'test' }, array: [1, 2, 3] };
+            const complexMockFunc = vi.fn();
+            complexMockFunc.mockResolvedValue('complex-result');
+            // 创建一个接受复杂参数的 CacheApi
+            const complexCacheApi = new CacheApi(complexMockFunc);
+            const result = await complexCacheApi.send(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();
+            expect(result).toBe('no-param-result');
+        });
+    });
+    describe('MobX 集成', () => {
+        it('value 应该是一个 computed 属性', () => {
+            // 通过检查属性描述符来验证这是一个 computed 属性
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(cacheApi), 'value');
+            expect(descriptor).toBeDefined();
+            expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.get).toBeDefined();
+            expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.set).toBeUndefined();
+        });
+        it('value 变化应该触发 MobX 反应', async () => {
+            let reactionCount = 0;
+            let lastValue = undefined;
+            // 创建一个简单的反应来监听 value 变化
+            const disposer = runInAction(() => {
+                const reaction = () => {
+                    reactionCount++;
+                    lastValue = cacheApi.value;
+                };
+                // 初始调用
+                reaction();
+                return reaction;
+            });
+            mockApiFunc.mockResolvedValue('new-value');
+            await cacheApi.send('test', 1);
+            // 清理
+            if (typeof disposer === 'function') {
+                disposer();
+            }
+            expect(lastValue).toBe('new-value');
+        });
+    });
+    describe('类型安全', () => {
+        it('应该保持参数类型安全', () => {
+            // 这个测试主要是在编译时进行类型检查
+            // 如果类型不匹配，TypeScript 编译器会报错
+            const typedApi = new CacheApi((str, num, bool) => {
+                return Promise.resolve({ result: `${str}-${num}-${bool}` });
+            });
+            // 正确的调用
+            expect(() => typedApi.send('test', 42, true)).not.toThrow();
+            // 以下调用在 TypeScript 中会产生编译错误（在运行时测试中跳过）
+            // typedApi.send('test', 'wrong-type', true)  // 第二个参数应该是 number
+            // typedApi.send('test', 42)  // 缺少第三个参数
+        });
+    });
+    describe('loading 状态', () => {
+        it('初始状态下 loading 应该为 false', () => {
+            expect(cacheApi.loading).toBe(false);
+        });
+        it('发送请求时 loading 应该为 true', async () => {
+            let resolveFn;
+            const promise = new Promise((resolve) => {
+                resolveFn = resolve;
+            });
+            mockApiFunc.mockReturnValue(promise);
+            // 开始请求
+            const sendPromise = cacheApi.send('test', 1);
+            // 此时应该是 loading 状态
+            expect(cacheApi.loading).toBe(true);
+            // 完成请求
+            resolveFn('result');
+            await sendPromise;
+            // 请求完成后 loading 应该为 false
+            expect(cacheApi.loading).toBe(false);
+        });
+        it('请求失败后 loading 应该为 false', async () => {
+            const error = new Error('API Error');
+            mockApiFunc.mockRejectedValue(error);
+            try {
+                await cacheApi.send('test', 1);
+            }
+            catch (e) {
+                // 忽略错误
+            }
+            expect(cacheApi.loading).toBe(false);
+        });
+        it('并发请求时 loading 状态应该正确处理', async () => {
+            const resolvers = [];
+            mockApiFunc.mockImplementation((param) => {
+                return new Promise((resolve) => {
+                    resolvers.push((value) => resolve(`${param}-${value}`));
+                });
+            });
+            // 启动三个并发请求
+            const promise1 = cacheApi.send('req1', 1);
+            const promise2 = cacheApi.send('req2', 2);
+            const promise3 = cacheApi.send('req3', 3);
+            // 此时应该有三个请求正在进行，loading 为 true
+            expect(cacheApi.loading).toBe(true);
+            // 完成第一个请求
+            resolvers[0]('result1');
+            await promise1;
+            // 还有两个请求在进行，loading 仍为 true
+            expect(cacheApi.loading).toBe(true);
+            // 完成第二个请求
+            resolvers[1]('result2');
+            await promise2;
+            // 还有一个请求在进行，loading 仍为 true
+            expect(cacheApi.loading).toBe(true);
+            // 完成第三个请求
+            resolvers[2]('result3');
+            await promise3;
+            // 所有请求完成，loading 为 false
+            expect(cacheApi.loading).toBe(false);
+        });
+        it('部分并发请求失败时 loading 状态应该正确', async () => {
+            let resolveSuccess;
+            let rejectError;
+            mockApiFunc.mockImplementation((param) => {
+                if (param === 'success') {
+                    return new Promise((resolve) => {
+                        resolveSuccess = resolve;
+                    });
+                }
+                else {
+                    return new Promise((_, reject) => {
+                        rejectError = reject;
+                    });
+                }
+            });
+            // 启动两个请求，一个成功一个失败
+            const successPromise = cacheApi.send('success', 1);
+            const errorPromise = cacheApi.send('error', 2);
+            expect(cacheApi.loading).toBe(true);
+            // 先让失败的请求完成
+            rejectError(new Error('Failed'));
+            try {
+                await errorPromise;
+            }
+            catch (e) {
+                // 忽略错误
+            }
+            // 还有一个成功的请求在进行，loading 仍为 true
+            expect(cacheApi.loading).toBe(true);
+            // 完成成功的请求
+            resolveSuccess('success-result');
+            await successPromise;
+            // 所有请求完成，loading 为 false
+            expect(cacheApi.loading).toBe(false);
+        });
+        it('loading 应该是一个 computed 属性', () => {
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(cacheApi), 'loading');
+            expect(descriptor).toBeDefined();
+            expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.get).toBeDefined();
+            expect(descriptor === null || descriptor === void 0 ? void 0 : descriptor.set).toBeUndefined();
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export { CacheApi } from './cache-api';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/helpers/cache-api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA"}

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

@@ -0,0 +1 @@
+export { CacheApi } from './cache-api';

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

@@ -1,7 +1,10 @@
 export declare class SideCache<T> {
+    private accessor emptyFlag;
     private accessor currentKey;
     private accessor cache;
-    get value(): T | null;
-    handle<F extends ((...args: unknown[]) => Promise<T | null>)>(key: unknown, func: F): Promise<T | null>;
+    get value(): T | undefined;
+    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;
 }
 //# sourceMappingURL=side-cache.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"side-cache.d.ts","sourceRoot":"","sources":["../../../source/helpers/side-cache/side-cache.ts"],"names":[],"mappings":"AAOA,qBAAa,SAAS,CAAC,CAAC;IAEtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IAGjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAE1D,IACW,KAAK,IAAI,CAAC,GAAG,IAAI,CAG3B;IAGY,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAiBrH"}
+{"version":3,"file":"side-cache.d.ts","sourceRoot":"","sources":["../../../source/helpers/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"}

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

@@ -44,10 +44,16 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 import { action, computed, observable, runInAction } from 'mobx';
+function isPromiseLike(value) {
+    return value != null && typeof value.then === 'function';
+}
 let SideCache = (() => {
-    var _a, _SideCache_currentKey_accessor_storage, _SideCache_cache_accessor_storage;
+    var _a, _SideCache_emptyFlag_accessor_storage, _SideCache_currentKey_accessor_storage, _SideCache_cache_accessor_storage;
     var _b, _c;
     let _instanceExtraInitializers = [];
+    let _emptyFlag_decorators;
+    let _emptyFlag_initializers = [];
+    let _emptyFlag_extraInitializers = [];
     let _currentKey_decorators;
     let _currentKey_initializers = [];
     let _currentKey_extraInitializers = [];
@@ -55,25 +61,44 @@ let SideCache = (() => {
     let _cache_initializers = [];
     let _cache_extraInitializers = [];
     let _get_value_decorators;
+    let _get_empty_decorators;
     let _handle_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"); }
             get currentKey() { return __classPrivateFieldGet(this, _SideCache_currentKey_accessor_storage, "f"); }
             set currentKey(value) { __classPrivateFieldSet(this, _SideCache_currentKey_accessor_storage, value, "f"); }
             get cache() { return __classPrivateFieldGet(this, _SideCache_cache_accessor_storage, "f"); }
             set cache(value) { __classPrivateFieldSet(this, _SideCache_cache_accessor_storage, value, "f"); }
             get value() {
-                var _b;
                 if (this.currentKey == null)
-                    return null;
-                return ((_b = this.cache[this.currentKey]) === null || _b === void 0 ? void 0 : _b.data) || null;
+                    return undefined;
+                const cacheItem = this.cache[this.currentKey];
+                return cacheItem ? cacheItem.data : undefined;
+            }
+            get empty() {
+                return this.emptyFlag;
             }
-            async handle(key, func) {
-                const keyStringify = JSON.stringify(key); // 不需要跨设备、软件一致，所以直接用 JSON.stringify
+            handle(key, func) {
+                var _b;
+                // 不需要跨设备、软件一致，所以直接用 JSON.stringify
+                // 但需要处理 JSON.stringify(undefined) 返回 undefined 的情况
+                const keyStringify = (_b = JSON.stringify(key)) !== null && _b !== void 0 ? _b : 'undefined';
+                // 这会让外面立马可以拿到之前缓存的值，如果存在的话
                 runInAction(() => this.currentKey = keyStringify);
-                const funcReturn = await func();
-                if (funcReturn == null)
-                    return funcReturn;
+                const funcReturn = func();
+                if (isPromiseLike(funcReturn)) {
+                    return funcReturn.then(result => runInAction(() => {
+                        this.emptyFlag = false;
+                        this.cache = Object.assign(Object.assign({}, this.cache), { [keyStringify]: {
+                                data: result,
+                                createTime: new Date().toISOString()
+                            } });
+                        return result;
+                    }));
+                }
                 runInAction(() => {
+                    this.emptyFlag = false;
                     this.cache = Object.assign(Object.assign({}, this.cache), { [keyStringify]: {
                             data: funcReturn,
                             createTime: new Date().toISOString()
@@ -82,22 +107,28 @@ let SideCache = (() => {
                 return funcReturn;
             }
             constructor() {
-                _SideCache_currentKey_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _currentKey_initializers, null)));
+                _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)));
                 _SideCache_cache_accessor_storage.set(this, (__runInitializers(this, _currentKey_extraInitializers), __runInitializers(this, _cache_initializers, {})));
                 __runInitializers(this, _cache_extraInitializers);
             }
         },
+        _SideCache_emptyFlag_accessor_storage = new WeakMap(),
         _SideCache_currentKey_accessor_storage = new WeakMap(),
         _SideCache_cache_accessor_storage = new WeakMap(),
         (() => {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _emptyFlag_decorators = [observable];
             _currentKey_decorators = [observable];
             _cache_decorators = [(_b = observable).ref.bind(_b)];
             _get_value_decorators = [computed];
+            _get_empty_decorators = [computed];
             _handle_decorators = [(_c = action).bound.bind(_c)];
+            __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);
             if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         })(),