@taicode/common-web 1.1.5 → 1.1.7

package/output/service/service.test.js

@@ -44,12 +44,30 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import { act } from 'react';
+import React, { act } from 'react';
 import { Service } from '@taicode/common-base';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { render, renderHook, waitFor } from '@testing-library/react';
 import { observable, makeObservable, runInAction, action } from 'mobx';
-import { useService, ServiceProvider } from './service';
+import { useService, useLocalService, ServiceProvider } from './service';
+class TestErrorBoundary extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.state = { error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(error) {
+        this.props.onError(error);
+    }
+    render() {
+        if (this.state.error) {
+            return null;
+        }
+        return this.props.children;
+    }
+}
 // 创建测试用的服务类
 let TestService = (() => {
     var _a, _TestService_count_accessor_storage, _TestService_users_accessor_storage, _TestService_inited_accessor_storage;
@@ -169,6 +187,143 @@ let SimpleService = (() => {
         })(),
         _a;
 })();
+// 局部服务测试类
+let LocalService = (() => {
+    var _a, _LocalService_data_accessor_storage, _LocalService_counter_accessor_storage, _LocalService_inited_accessor_storage;
+    let _classSuper = Service;
+    let _instanceExtraInitializers = [];
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
+    let _counter_decorators;
+    let _counter_initializers = [];
+    let _counter_extraInitializers = [];
+    let _inited_decorators;
+    let _inited_initializers = [];
+    let _inited_extraInitializers = [];
+    let _increment_decorators;
+    let _setData_decorators;
+    return _a = class LocalService extends _classSuper {
+            get data() { return __classPrivateFieldGet(this, _LocalService_data_accessor_storage, "f"); }
+            set data(value) { __classPrivateFieldSet(this, _LocalService_data_accessor_storage, value, "f"); }
+            get counter() { return __classPrivateFieldGet(this, _LocalService_counter_accessor_storage, "f"); }
+            set counter(value) { __classPrivateFieldSet(this, _LocalService_counter_accessor_storage, value, "f"); }
+            get inited() { return __classPrivateFieldGet(this, _LocalService_inited_accessor_storage, "f"); }
+            set inited(value) { __classPrivateFieldSet(this, _LocalService_inited_accessor_storage, value, "f"); }
+            constructor() {
+                super();
+                _LocalService_data_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _data_initializers, 'local')));
+                _LocalService_counter_accessor_storage.set(this, (__runInitializers(this, _data_extraInitializers), __runInitializers(this, _counter_initializers, 0)));
+                _LocalService_inited_accessor_storage.set(this, (__runInitializers(this, _counter_extraInitializers), __runInitializers(this, _inited_initializers, false)));
+                __runInitializers(this, _inited_extraInitializers);
+                makeObservable(this);
+            }
+            async init() {
+                runInAction(() => {
+                    this.data = 'initialized';
+                });
+                return true;
+            }
+            increment() {
+                this.counter++;
+            }
+            setData(newData) {
+                this.data = newData;
+            }
+        },
+        _LocalService_data_accessor_storage = new WeakMap(),
+        _LocalService_counter_accessor_storage = new WeakMap(),
+        _LocalService_inited_accessor_storage = new WeakMap(),
+        (() => {
+            var _b;
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+            _data_decorators = [observable];
+            _counter_decorators = [observable];
+            _inited_decorators = [observable];
+            _increment_decorators = [action];
+            _setData_decorators = [action];
+            __esDecorate(_a, null, _data_decorators, { kind: "accessor", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
+            __esDecorate(_a, null, _counter_decorators, { kind: "accessor", name: "counter", static: false, private: false, access: { has: obj => "counter" in obj, get: obj => obj.counter, set: (obj, value) => { obj.counter = value; } }, metadata: _metadata }, _counter_initializers, _counter_extraInitializers);
+            __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+            __esDecorate(_a, null, _increment_decorators, { kind: "method", name: "increment", static: false, private: false, access: { has: obj => "increment" in obj, get: obj => obj.increment }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _setData_decorators, { kind: "method", name: "setData", static: false, private: false, access: { has: obj => "setData" in obj, get: obj => obj.setData }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+// 依赖注入测试服务类 - 简化版本，不使用装饰器
+let DependentService = (() => {
+    var _a, _DependentService_combinedData_accessor_storage, _DependentService_inited_accessor_storage;
+    let _classSuper = Service;
+    let _combinedData_decorators;
+    let _combinedData_initializers = [];
+    let _combinedData_extraInitializers = [];
+    let _inited_decorators;
+    let _inited_initializers = [];
+    let _inited_extraInitializers = [];
+    return _a = class DependentService extends _classSuper {
+            get combinedData() { return __classPrivateFieldGet(this, _DependentService_combinedData_accessor_storage, "f"); }
+            set combinedData(value) { __classPrivateFieldSet(this, _DependentService_combinedData_accessor_storage, value, "f"); }
+            get inited() { return __classPrivateFieldGet(this, _DependentService_inited_accessor_storage, "f"); }
+            set inited(value) { __classPrivateFieldSet(this, _DependentService_inited_accessor_storage, value, "f"); }
+            constructor() {
+                super();
+                _DependentService_combinedData_accessor_storage.set(this, __runInitializers(this, _combinedData_initializers, ''));
+                _DependentService_inited_accessor_storage.set(this, (__runInitializers(this, _combinedData_extraInitializers), __runInitializers(this, _inited_initializers, false)));
+                __runInitializers(this, _inited_extraInitializers);
+                makeObservable(this);
+            }
+            async init() {
+                runInAction(() => {
+                    this.combinedData = `dependent-simple`;
+                });
+                return true;
+            }
+        },
+        _DependentService_combinedData_accessor_storage = new WeakMap(),
+        _DependentService_inited_accessor_storage = new WeakMap(),
+        (() => {
+            var _b;
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+            _combinedData_decorators = [observable];
+            _inited_decorators = [observable];
+            __esDecorate(_a, null, _combinedData_decorators, { kind: "accessor", name: "combinedData", static: false, private: false, access: { has: obj => "combinedData" in obj, get: obj => obj.combinedData, set: (obj, value) => { obj.combinedData = value; } }, metadata: _metadata }, _combinedData_initializers, _combinedData_extraInitializers);
+            __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+// 普通类（不继承 Service）
+let PlainClass = (() => {
+    var _a, _PlainClass_value_accessor_storage;
+    let _instanceExtraInitializers = [];
+    let _value_decorators;
+    let _value_initializers = [];
+    let _value_extraInitializers = [];
+    let _updateValue_decorators;
+    return _a = class PlainClass {
+            get value() { return __classPrivateFieldGet(this, _PlainClass_value_accessor_storage, "f"); }
+            set value(value) { __classPrivateFieldSet(this, _PlainClass_value_accessor_storage, value, "f"); }
+            constructor() {
+                _PlainClass_value_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _value_initializers, 'plain')));
+                __runInitializers(this, _value_extraInitializers);
+                makeObservable(this);
+            }
+            updateValue() {
+                this.value = 'updated';
+            }
+        },
+        _PlainClass_value_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _value_decorators = [observable];
+            _updateValue_decorators = [action];
+            __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+            __esDecorate(_a, null, _updateValue_decorators, { kind: "method", name: "updateValue", static: false, private: false, access: { has: obj => "updateValue" in obj, get: obj => obj.updateValue }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 // 创建测试用的 Provider 组件
 function createTestProvider(services) {
     return function TestProvider({ children }) {
@@ -232,6 +387,63 @@ describe('service integration', () => {
             expect(result.current.count).toBe(0);
             expect(result.current.value).toBe('initial');
         });
+        it('在未提供 selector 时应该返回完整服务实例并响应更新', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useService(TestService), { wrapper: TestProvider });
+            const firstInstance = result.current;
+            expect(firstInstance.count).toBe(0);
+            act(() => {
+                firstInstance.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.count).toBe(1);
+            });
+            expect(result.current).toBe(firstInstance);
+        });
+        it('当 selector 返回服务实例时应该退化为监听全部属性', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                serviceViaSelector: useService(TestService, service => service),
+                counter: useService(TestService, service => service.count)
+            }), { wrapper: TestProvider });
+            const initialServiceRef = result.current.serviceViaSelector;
+            expect(initialServiceRef.count).toBe(0);
+            act(() => {
+                initialServiceRef.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.counter).toBe(1);
+                expect(result.current.serviceViaSelector.count).toBe(1);
+            });
+            expect(result.current.serviceViaSelector).toBe(initialServiceRef);
+        });
+        it('useService 的 selector 应该能够响应其他服务的 observable 变化', async () => {
+            const TestProvider = createTestProvider([TestService, AnotherService]);
+            const { result } = renderHook(() => {
+                const globalService = useService(TestService, service => service);
+                const anotherSelection = useService(AnotherService, service => ({
+                    service,
+                    combined: `${service.value}-${globalService.count}`
+                }));
+                return {
+                    globalService,
+                    anotherSelection
+                };
+            }, { wrapper: TestProvider });
+            expect(result.current.anotherSelection.combined).toBe('initial-0');
+            act(() => {
+                result.current.anotherSelection.service.setValue('changed');
+            });
+            await waitFor(() => {
+                expect(result.current.anotherSelection.combined).toBe('changed-0');
+            });
+            act(() => {
+                result.current.globalService.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.anotherSelection.combined).toBe('changed-1');
+            });
+        });
     });
     describe('ServiceProvider', () => {
         it('应该能够渲染子组件', () => {
@@ -309,6 +521,207 @@ describe('service integration', () => {
                 expect(result.current).toBe(false); // 因为初始化失败，inited 应该保持 false
             });
         });
+        it('在服务已初始化时不会重复调用 init', async () => {
+            const initSpy = vi.fn(async () => true);
+            let PreInitedService = (() => {
+                var _a, _PreInitedService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class PreInitedService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _PreInitedService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _PreInitedService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _PreInitedService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, true));
+                            this.init = (__runInitializers(this, _inited_extraInitializers), initSpy);
+                            makeObservable(this);
+                        }
+                    },
+                    _PreInitedService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([PreInitedService]);
+            const { result } = renderHook(() => useService(PreInitedService, service => ({
+                inited: service.inited,
+                service
+            })), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+            });
+            expect(initSpy).not.toHaveBeenCalled();
+        });
+        it('应该正确处理同步 init 的服务', async () => {
+            let SyncInitService = (() => {
+                var _a, _SyncInitService_inited_accessor_storage, _SyncInitService_value_accessor_storage;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                let _value_decorators;
+                let _value_initializers = [];
+                let _value_extraInitializers = [];
+                return _a = class SyncInitService {
+                        get inited() { return __classPrivateFieldGet(this, _SyncInitService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _SyncInitService_inited_accessor_storage, value, "f"); }
+                        get value() { return __classPrivateFieldGet(this, _SyncInitService_value_accessor_storage, "f"); }
+                        set value(value) { __classPrivateFieldSet(this, _SyncInitService_value_accessor_storage, value, "f"); }
+                        constructor() {
+                            _SyncInitService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            _SyncInitService_value_accessor_storage.set(this, (__runInitializers(this, _inited_extraInitializers), __runInitializers(this, _value_initializers, 'pending')));
+                            __runInitializers(this, _value_extraInitializers);
+                            makeObservable(this);
+                        }
+                        init() {
+                            runInAction(() => {
+                                this.value = 'ready';
+                                this.inited = true;
+                            });
+                            return true;
+                        }
+                    },
+                    _SyncInitService_inited_accessor_storage = new WeakMap(),
+                    _SyncInitService_value_accessor_storage = new WeakMap(),
+                    (() => {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+                        _inited_decorators = [observable];
+                        _value_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([SyncInitService]);
+            const { result } = renderHook(() => useService(SyncInitService, service => ({
+                inited: service.inited,
+                value: service.value
+            })), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+                expect(result.current.value).toBe('ready');
+            });
+        });
+        it('应该为多个服务分别调用 init', async () => {
+            const firstInit = vi.fn(async () => true);
+            const secondInit = vi.fn(async () => true);
+            let FirstInitService = (() => {
+                var _a, _FirstInitService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class FirstInitService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _FirstInitService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _FirstInitService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _FirstInitService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            this.init = (__runInitializers(this, _inited_extraInitializers), firstInit);
+                            makeObservable(this);
+                        }
+                    },
+                    _FirstInitService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            let SecondInitService = (() => {
+                var _a, _SecondInitService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class SecondInitService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _SecondInitService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _SecondInitService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _SecondInitService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            this.init = (__runInitializers(this, _inited_extraInitializers), secondInit);
+                            makeObservable(this);
+                        }
+                    },
+                    _SecondInitService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([FirstInitService, SecondInitService]);
+            const { result } = renderHook(() => ({
+                firstInited: useService(FirstInitService, service => service.inited),
+                secondInited: useService(SecondInitService, service => service.inited)
+            }), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.firstInited).toBe(true);
+                expect(result.current.secondInited).toBe(true);
+            });
+            expect(firstInit).toHaveBeenCalledTimes(1);
+            expect(secondInit).toHaveBeenCalledTimes(1);
+        });
+        it('在 init 返回非布尔值时应该抛出错误', async () => {
+            var _a;
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            let InvalidReturnService = (() => {
+                var _a, _InvalidReturnService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class InvalidReturnService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _InvalidReturnService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _InvalidReturnService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _InvalidReturnService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            __runInitializers(this, _inited_extraInitializers);
+                            makeObservable(this);
+                        }
+                        async init() {
+                            return 'invalid';
+                        }
+                    },
+                    _InvalidReturnService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([InvalidReturnService]);
+            const capturedErrors = [];
+            const Wrapper = ({ children }) => (_jsx(TestErrorBoundary, { onError: error => capturedErrors.push(error), children: _jsx(TestProvider, { children: children }) }));
+            try {
+                renderHook(() => useService(InvalidReturnService, service => service.inited), { wrapper: Wrapper });
+                await waitFor(() => {
+                    expect(capturedErrors[0]).toBeInstanceOf(Error);
+                });
+                expect((_a = capturedErrors[0]) === null || _a === void 0 ? void 0 : _a.message).toBe('Service init must return a boolean value.');
+            }
+            finally {
+                errorSpy.mockRestore();
+            }
+        });
     });
     describe('边界情况', () => {
         it('useService 应该能够处理选择器返回 undefined 的情况', () => {
@@ -355,4 +768,632 @@ describe('service integration', () => {
             expect(renderCount).toBeGreaterThanOrEqual(initialRenderCount);
         });
     });
+    describe('useLocalService', () => {
+        it('应该能够创建局部服务实例', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService, service => service.data), { wrapper: TestProvider });
+            // 初始状态应该是已经初始化的，因为初始化是同步的
+            expect(result.current).toBe('initialized');
+        });
+        it('应该在没有 ServiceProvider 时抛出错误', () => {
+            expect(() => {
+                renderHook(() => useLocalService(LocalService, service => service.data));
+            }).toThrow('Must be a child of ServiceProvider.');
+        });
+        it('应该自动初始化局部服务实例', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService, service => ({
+                data: service.data,
+                inited: service.inited
+            })), { wrapper: TestProvider });
+            // 等待初始化完成
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+                expect(result.current.data).toBe('initialized');
+            });
+        });
+        it('应该在服务数据变化时触发重新渲染', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService, service => ({
+                counter: service.counter,
+                service
+            })), { wrapper: TestProvider });
+            expect(result.current.counter).toBe(0);
+            // 修改服务数据
+            act(() => {
+                result.current.service.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.counter).toBe(1);
+            });
+        });
+        it('应该在组件重渲染时保持服务实例引用稳定', () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result, rerender } = renderHook(() => useLocalService(LocalService, service => service), { wrapper: TestProvider });
+            const firstInstance = result.current;
+            rerender();
+            const secondInstance = result.current;
+            expect(firstInstance).toBe(secondInstance);
+        });
+        it('应该为不同的 hook 调用创建不同的服务实例', () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                service1: useLocalService(LocalService, service => service),
+                service2: useLocalService(LocalService, service => service)
+            }), { wrapper: TestProvider });
+            expect(result.current.service1).not.toBe(result.current.service2);
+        });
+        it('应该支持依赖注入全局服务', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                localService: useLocalService(DependentService, service => service),
+                globalService: useService(TestService, service => service)
+            }), { wrapper: TestProvider });
+            // 修改全局服务的数据
+            act(() => {
+                result.current.globalService.increment();
+                result.current.globalService.increment();
+            });
+            // 等待局部服务初始化完成
+            await waitFor(() => {
+                expect(result.current.localService.inited).toBe(true);
+                expect(result.current.localService.combinedData).toBe('dependent-simple');
+            }, { timeout: 3000 });
+        });
+        it('应该能够处理复杂的选择器', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            let serviceRef = null;
+            const { result } = renderHook(() => useLocalService(LocalService, service => {
+                serviceRef = service; // 保存服务引用
+                return {
+                    hasData: service.data.length > 0,
+                    upperData: service.data.toUpperCase(),
+                    rawData: service.data, // 添加原始数据用于调试
+                };
+            }), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.hasData).toBe(true);
+                expect(result.current.upperData).toBe('INITIALIZED');
+            });
+            // 修改数据 - 使用选择器内部捕获的服务实例
+            act(() => {
+                serviceRef.setData('modified');
+            });
+            await waitFor(() => {
+                expect(result.current.upperData).toBe('MODIFIED');
+            });
+        });
+        it('应该能够处理选择器返回 undefined 的情况', () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService, () => undefined), { wrapper: TestProvider });
+            expect(result.current).toBeUndefined();
+        });
+        it('应该能够处理局部服务初始化失败的情况', async () => {
+            // 创建一个初始化会失败的局部服务
+            let FailingLocalService = (() => {
+                var _a, _FailingLocalService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class FailingLocalService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _FailingLocalService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _FailingLocalService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _FailingLocalService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            __runInitializers(this, _inited_extraInitializers);
+                            makeObservable(this);
+                        }
+                        async init() {
+                            throw new Error('Init failed');
+                        }
+                    },
+                    _FailingLocalService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(FailingLocalService, service => service.inited), { wrapper: TestProvider });
+            // 等待初始化处理完成，即使失败也应该保持 inited 为 false
+            await waitFor(() => {
+                expect(result.current).toBe(false);
+            });
+        });
+        it('在 init 返回非布尔值时应该抛出错误', async () => {
+            var _a;
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            let InvalidReturnLocalService = (() => {
+                var _a, _InvalidReturnLocalService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class InvalidReturnLocalService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _InvalidReturnLocalService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _InvalidReturnLocalService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _InvalidReturnLocalService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            __runInitializers(this, _inited_extraInitializers);
+                            makeObservable(this);
+                        }
+                        async init() {
+                            return 'invalid';
+                        }
+                    },
+                    _InvalidReturnLocalService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([TestService]);
+            const capturedErrors = [];
+            const Wrapper = ({ children }) => (_jsx(TestErrorBoundary, { onError: error => capturedErrors.push(error), children: _jsx(TestProvider, { children: children }) }));
+            try {
+                renderHook(() => useLocalService(InvalidReturnLocalService, service => service.inited), { wrapper: Wrapper });
+                await waitFor(() => {
+                    expect(capturedErrors[0]).toBeInstanceOf(Error);
+                });
+                expect((_a = capturedErrors[0]) === null || _a === void 0 ? void 0 : _a.message).toBe('Service init must return a boolean value.');
+            }
+            finally {
+                errorSpy.mockRestore();
+            }
+        });
+        it('应该能够处理没有实现 Service 接口的局部服务', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(PlainClass, service => ({
+                value: service.value,
+                service
+            })), { wrapper: TestProvider });
+            expect(result.current.value).toBe('plain');
+            // 修改数据
+            act(() => {
+                result.current.service.updateValue();
+            });
+            await waitFor(() => {
+                expect(result.current.value).toBe('updated');
+            });
+        });
+        it('应该在选择器函数变化时正确更新订阅', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            let useData = true;
+            const { result, rerender } = renderHook(() => useLocalService(LocalService, service => ({
+                selected: useData ? service.data : service.counter,
+                service
+            })), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.selected).toBe('initialized');
+            });
+            // 修改 selector
+            useData = false;
+            rerender();
+            await waitFor(() => {
+                expect(result.current.selected).toBe(0);
+            });
+            // 修改计数器
+            act(() => {
+                result.current.service.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.selected).toBe(1);
+            });
+        });
+        it('不应该产生全局状态的干扰', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            let globalServiceRef = null;
+            let localServiceRef1 = null;
+            let localServiceRef2 = null;
+            // 第一个组件：使用全局服务和局部服务
+            const { result: result1 } = renderHook(() => ({
+                globalService: useService(TestService, service => {
+                    globalServiceRef = service;
+                    return service;
+                }),
+                localService: useLocalService(LocalService, service => {
+                    localServiceRef1 = service;
+                    return service;
+                })
+            }), { wrapper: TestProvider });
+            // 第二个组件：使用另一个局部服务实例
+            const { result: result2 } = renderHook(() => ({
+                localService: useLocalService(LocalService, service => {
+                    localServiceRef2 = service;
+                    return service;
+                })
+            }), { wrapper: TestProvider });
+            // 等待初始化完成
+            await waitFor(() => {
+                expect(result1.current.globalService.inited).toBe(true);
+                expect(result1.current.localService.inited).toBe(true);
+                expect(result2.current.localService.inited).toBe(true);
+            });
+            // 验证基本状态
+            expect(globalServiceRef).not.toBeNull();
+            expect(localServiceRef1).not.toBeNull();
+            expect(localServiceRef2).not.toBeNull();
+            // 验证局部服务实例是不同的
+            expect(localServiceRef1).not.toBe(localServiceRef2);
+            // 验证局部服务与全局服务是不同的
+            expect(localServiceRef1).not.toBe(globalServiceRef);
+            expect(localServiceRef2).not.toBe(globalServiceRef);
+            // 修改第一个局部服务的状态
+            act(() => {
+                localServiceRef1.increment();
+                localServiceRef1.setData('local1-changed');
+            });
+            await waitFor(() => {
+                expect(result1.current.localService.counter).toBe(1);
+                expect(result1.current.localService.data).toBe('local1-changed');
+            });
+            // 验证其他服务状态未受影响
+            expect(result2.current.localService.counter).toBe(0);
+            expect(result2.current.localService.data).toBe('initialized');
+            expect(result1.current.globalService.count).toBe(0);
+            // 修改第二个局部服务的状态
+            act(() => {
+                localServiceRef2.increment();
+                localServiceRef2.increment();
+                localServiceRef2.setData('local2-changed');
+            });
+            await waitFor(() => {
+                expect(result2.current.localService.counter).toBe(2);
+                expect(result2.current.localService.data).toBe('local2-changed');
+            });
+            // 验证其他服务状态仍未受影响
+            expect(result1.current.localService.counter).toBe(1);
+            expect(result1.current.localService.data).toBe('local1-changed');
+            expect(result1.current.globalService.count).toBe(0);
+            // 修改全局服务状态
+            act(() => {
+                globalServiceRef.increment();
+                globalServiceRef.addUser('Charlie');
+            });
+            await waitFor(() => {
+                expect(result1.current.globalService.count).toBe(1);
+                expect(result1.current.globalService.users).toEqual(['Alice', 'Bob', 'Charlie']);
+            });
+            // 验证局部服务状态未受全局服务影响
+            expect(result1.current.localService.counter).toBe(1);
+            expect(result1.current.localService.data).toBe('local1-changed');
+            expect(result2.current.localService.counter).toBe(2);
+            expect(result2.current.localService.data).toBe('local2-changed');
+            // 最终验证：每个服务实例都保持独立的状态
+            expect(result1.current.globalService.count).toBe(1);
+            expect(result1.current.globalService.users.length).toBe(3);
+            expect(result1.current.localService.counter).toBe(1);
+            expect(result1.current.localService.data).toBe('local1-changed');
+            expect(result2.current.localService.counter).toBe(2);
+            expect(result2.current.localService.data).toBe('local2-changed');
+        });
+        it('当 selector 返回服务实例时应该退化为监听全部属性', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService, service => service), { wrapper: TestProvider });
+            const firstInstance = result.current;
+            expect(firstInstance.counter).toBe(0);
+            act(() => {
+                firstInstance.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.counter).toBe(1);
+            });
+            expect(result.current).toBe(firstInstance);
+        });
+        it('应该在卸载后重新创建新的服务实例', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result, unmount } = renderHook(() => useLocalService(LocalService, service => service), { wrapper: TestProvider });
+            const firstInstance = result.current;
+            await waitFor(() => {
+                expect(firstInstance.inited).toBe(true);
+            });
+            unmount();
+            const { result: result2 } = renderHook(() => useLocalService(LocalService, service => service), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result2.current.inited).toBe(true);
+            });
+            expect(result2.current).not.toBe(firstInstance);
+        });
+        it('应该只在首次挂载时调用一次 init', async () => {
+            const initSpy = vi.fn(async () => true);
+            let InitOnceLocalService = (() => {
+                var _a, _InitOnceLocalService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class InitOnceLocalService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _InitOnceLocalService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _InitOnceLocalService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _InitOnceLocalService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            this.init = (__runInitializers(this, _inited_extraInitializers), initSpy);
+                            makeObservable(this);
+                        }
+                    },
+                    _InitOnceLocalService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([TestService]);
+            const { result, rerender } = renderHook(() => useLocalService(InitOnceLocalService, service => service.inited), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current).toBe(true);
+            });
+            rerender();
+            await waitFor(() => {
+                expect(result.current).toBe(true);
+            });
+            expect(initSpy).toHaveBeenCalledTimes(1);
+        });
+        it('在同一组件中混用全局与局部的同类服务时应该保持状态独立', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                global: useService(TestService, service => ({
+                    service,
+                    count: service.count,
+                    users: [...service.users]
+                })),
+                local: useLocalService(TestService, service => ({
+                    service,
+                    count: service.count,
+                    users: [...service.users]
+                }))
+            }), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.global.users).toEqual(['Alice', 'Bob']);
+                expect(result.current.local.users).toEqual(['Alice', 'Bob']);
+            });
+            expect(result.current.global.service).not.toBe(result.current.local.service);
+            act(() => {
+                result.current.global.service.increment();
+                result.current.global.service.addUser('GlobalCharlie');
+            });
+            await waitFor(() => {
+                expect(result.current.global.count).toBe(1);
+                expect(result.current.global.users).toEqual(['Alice', 'Bob', 'GlobalCharlie']);
+            });
+            expect(result.current.local.count).toBe(0);
+            expect(result.current.local.users).toEqual(['Alice', 'Bob']);
+            act(() => {
+                result.current.local.service.increment();
+                result.current.local.service.addUser('LocalCharlie');
+            });
+            await waitFor(() => {
+                expect(result.current.local.count).toBe(1);
+                expect(result.current.local.users).toEqual(['Alice', 'Bob', 'LocalCharlie']);
+            });
+            expect(result.current.global.count).toBe(1);
+            expect(result.current.global.users).toEqual(['Alice', 'Bob', 'GlobalCharlie']);
+        });
+        it('同一服务在全局与局部同时使用时应该分别初始化', async () => {
+            const initSpy = vi.fn(async function () {
+                runInAction(() => {
+                    this.inited = true;
+                });
+                return true;
+            });
+            let InitSpyService = (() => {
+                var _a, _InitSpyService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class InitSpyService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _InitSpyService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _InitSpyService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _InitSpyService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            this.init = (__runInitializers(this, _inited_extraInitializers), initSpy);
+                            makeObservable(this);
+                        }
+                    },
+                    _InitSpyService_inited_accessor_storage = new WeakMap(),
+                    (() => {
+                        var _b;
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+                        _inited_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const TestProvider = createTestProvider([InitSpyService]);
+            const { result } = renderHook(() => ({
+                global: useService(InitSpyService, service => ({
+                    service,
+                    inited: service.inited
+                })),
+                local: useLocalService(InitSpyService, service => ({
+                    service,
+                    inited: service.inited
+                }))
+            }), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.global.inited).toBe(true);
+                expect(result.current.local.inited).toBe(true);
+            });
+            expect(result.current.global.service).not.toBe(result.current.local.service);
+            expect(initSpy).toHaveBeenCalledTimes(2);
+            const instances = initSpy.mock.instances;
+            expect(new Set(instances).size).toBe(2);
+            instances.forEach(instance => {
+                expect(instance.inited).toBe(true);
+            });
+        });
+        it('useLocalService 的 selector 应该能够响应全局服务的 observable 变化', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => {
+                const globalService = useService(TestService, service => service);
+                const localSelection = useLocalService(LocalService, service => ({
+                    service,
+                    combined: `${service.counter}-${globalService.count}`
+                }));
+                return {
+                    globalService,
+                    localSelection
+                };
+            }, { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.localSelection.service.inited).toBe(true);
+            });
+            expect(result.current.localSelection.combined).toBe('0-0');
+            act(() => {
+                result.current.globalService.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.localSelection.combined).toBe('0-1');
+            });
+            act(() => {
+                result.current.localSelection.service.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.localSelection.combined).toBe('1-1');
+            });
+        });
+    });
+    describe('useLocalService 可选 selector 功能', () => {
+        it('应该在不传入 selector 时返回完整的服务实例', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+            });
+            expect(result.current.data).toBe('initialized');
+            expect(result.current.counter).toBe(0);
+            expect(typeof result.current.increment).toBe('function');
+        });
+        it('应该在不传入 selector 时响应任意属性的变化', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+            });
+            // 初始值
+            expect(result.current.data).toBe('initialized');
+            expect(result.current.counter).toBe(0);
+            // 修改计数器
+            act(() => {
+                result.current.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.counter).toBe(1);
+            });
+            // 修改数据
+            act(() => {
+                result.current.setData('updated');
+            });
+            await waitFor(() => {
+                expect(result.current.data).toBe('updated');
+            });
+        });
+        it('应该支持函数重载，有 selector 时返回选择器结果', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                service: useLocalService(LocalService),
+                counter: useLocalService(LocalService, s => s.counter),
+                data: useLocalService(LocalService, s => s.data)
+            }), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.service.inited).toBe(true);
+            });
+            // 类型验证：service 应该是完整的服务实例
+            expect(typeof result.current.service.increment).toBe('function');
+            expect(typeof result.current.service.setData).toBe('function');
+            // 类型验证：counter 应该是 number 类型
+            expect(typeof result.current.counter).toBe('number');
+            // 类型验证：data 应该是 string 类型
+            expect(typeof result.current.data).toBe('string');
+            expect(result.current.counter).toBe(0);
+            expect(result.current.data).toBe('initialized');
+        });
+        it('应该在不传入 selector 时支持多个属性同时变化的响应', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useLocalService(LocalService), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+            });
+            // 初始状态
+            expect(result.current.counter).toBe(0);
+            expect(result.current.data).toBe('initialized');
+            // 同时修改多个属性
+            act(() => {
+                result.current.increment();
+                result.current.setData('changed');
+            });
+            await waitFor(() => {
+                expect(result.current.counter).toBe(1);
+                expect(result.current.data).toBe('changed');
+            });
+        });
+        it('应该正确处理同步 init 的局部服务', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            let SyncInitLocalService = (() => {
+                var _a, _SyncInitLocalService_inited_accessor_storage, _SyncInitLocalService_value_accessor_storage;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                let _value_decorators;
+                let _value_initializers = [];
+                let _value_extraInitializers = [];
+                return _a = class SyncInitLocalService {
+                        get inited() { return __classPrivateFieldGet(this, _SyncInitLocalService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _SyncInitLocalService_inited_accessor_storage, value, "f"); }
+                        get value() { return __classPrivateFieldGet(this, _SyncInitLocalService_value_accessor_storage, "f"); }
+                        set value(value) { __classPrivateFieldSet(this, _SyncInitLocalService_value_accessor_storage, value, "f"); }
+                        constructor() {
+                            _SyncInitLocalService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            _SyncInitLocalService_value_accessor_storage.set(this, (__runInitializers(this, _inited_extraInitializers), __runInitializers(this, _value_initializers, 'pending')));
+                            __runInitializers(this, _value_extraInitializers);
+                            makeObservable(this);
+                        }
+                        init() {
+                            runInAction(() => {
+                                this.value = 'ready';
+                                this.inited = true;
+                            });
+                            return true;
+                        }
+                    },
+                    _SyncInitLocalService_inited_accessor_storage = new WeakMap(),
+                    _SyncInitLocalService_value_accessor_storage = new WeakMap(),
+                    (() => {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+                        _inited_decorators = [observable];
+                        _value_decorators = [observable];
+                        __esDecorate(_a, null, _inited_decorators, { kind: "accessor", name: "inited", static: false, private: false, access: { has: obj => "inited" in obj, get: obj => obj.inited, set: (obj, value) => { obj.inited = value; } }, metadata: _metadata }, _inited_initializers, _inited_extraInitializers);
+                        __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+                        if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    })(),
+                    _a;
+            })();
+            const { result } = renderHook(() => useLocalService(SyncInitLocalService, service => ({
+                inited: service.inited,
+                value: service.value
+            })), { wrapper: TestProvider });
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+                expect(result.current.value).toBe('ready');
+            });
+        });
+    });
 });