@taicode/common-web 1.1.6 → 1.1.7

package/output/service/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../source/service/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAA2D,MAAM,OAAO,CAAA;AAQ/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAClD,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAgDlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;AAC9E,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAoG9G;;GAEG;AACH,UAAU,oBAAoB;IAC5B,sBAAsB;IACtB,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAA;IAC7B,UAAU;IACV,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,6CAA6C;AAE7C,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,8EAuB1D"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../source/service/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAA2D,MAAM,OAAO,CAAA;AA+D/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAClD,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAgDlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;AAC9E,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAyF9G;;GAEG;AACH,UAAU,oBAAoB;IAC5B,sBAAsB;IACtB,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAA;IAC7B,UAAU;IACV,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,6CAA6C;AAE7C,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,8EAuB1D"}

package/output/service/service.js

@@ -33,7 +33,6 @@
  * ```
  */
 import { reaction, runInAction } from 'mobx';
-import { catchIt } from '@taicode/common-base';
 import { Container } from '@needle-di/core';
 import React, { useContext, useEffect, useMemo, useState, useRef } from 'react';
 /**
@@ -41,6 +40,50 @@ import React, { useContext, useEffect, useMemo, useState, useRef } from 'react';
  * 通过上下文在组件树中共享依赖注入容器
  */
 const ctx = React.createContext(undefined);
+const INIT_RETURN_ERROR_MESSAGE = 'Service init must return a boolean value.';
+class InvalidInitReturnError extends Error {
+    constructor() {
+        super(INIT_RETURN_ERROR_MESSAGE);
+        this.name = 'InvalidInitReturnError';
+    }
+}
+function setServiceInited(target, value) {
+    runInAction(() => {
+        if (target != null && typeof target === 'object') {
+            target.inited = value;
+        }
+    });
+}
+function applyInitResult(target, result) {
+    if (typeof result === 'boolean') {
+        setServiceInited(target, result);
+        return;
+    }
+    setServiceInited(target, false);
+    throw new InvalidInitReturnError();
+}
+async function initializeServiceInstance(target) {
+    if (target == null ||
+        typeof target !== 'object' ||
+        !('init' in target) ||
+        typeof target.init !== 'function') {
+        return;
+    }
+    const service = target;
+    if (service.inited === true) {
+        return;
+    }
+    try {
+        const result = await service.init();
+        applyInitResult(service, result);
+    }
+    catch (error) {
+        if (error instanceof InvalidInitReturnError) {
+            throw error;
+        }
+        setServiceInited(service, false);
+    }
+}
 export function useService(target, selector) {
     const container = useContext(ctx);
     // 使用 useState 强制组件重新渲染
@@ -84,6 +127,7 @@ export function useLocalService(ServiceClass, selector) {
     const serviceInstanceRef = useRef(null);
     // 使用 useState 强制组件重新渲染，完全模仿 useService
     const [, refresh] = useState({});
+    const [initError, setInitError] = useState(null);
     if (parentContainer == null) {
         throw new Error('Must be a child of ServiceProvider.');
     }
@@ -125,34 +169,21 @@ export function useLocalService(ServiceClass, selector) {
     React.useEffect(() => {
         if (parentContainer == null)
             return;
+        let disposed = false;
+        setInitError(prev => (prev === null ? prev : null));
         const service = serviceInstanceRef.current;
-        // 自动初始化服务（如果实现了 Service 接口）
-        if (service != null &&
-            typeof service === 'object' &&
-            'init' in service &&
-            typeof service.init === 'function') {
-            // 直接调用 init 方法
-            const initResult = service.init();
-            if (initResult && typeof initResult.then === 'function') {
-                // 异步初始化
-                initResult.then((result) => {
-                    runInAction(() => {
-                        service.inited = result;
-                    });
-                }).catch((error) => {
-                    runInAction(() => {
-                        service.inited = false;
-                    });
-                });
-            }
-            else {
-                // 同步初始化
-                runInAction(() => {
-                    service.inited = true;
-                });
+        initializeServiceInstance(service).catch((error) => {
+            if (error instanceof InvalidInitReturnError && !disposed) {
+                setInitError(error);
             }
-        }
+        });
+        return () => {
+            disposed = true;
+        };
     }, [parentContainer, ServiceClass]); // 注意：这里不依赖 selector
+    if (initError) {
+        throw initError;
+    }
     // 返回选择器结果或服务实例
     return selector ? selector(serviceInstanceRef.current) : serviceInstanceRef.current;
 }
@@ -228,32 +259,38 @@ export function ServiceProvider(props) {
 function InitService(props) {
     const { services, children } = props;
     const container = useContext(ctx);
+    const [initError, setInitError] = React.useState(null);
     useEffect(() => {
         if (container == null)
             return;
         if (services.length == 0)
             return;
+        let disposed = false;
+        setInitError(prev => (prev === null ? prev : null));
         // 异步初始化所有服务
-        (async () => {
-            const initPromises = services.map(async (service) => {
-                // 尝试从容器中获取服务实例（可选的，避免未注册时报错）
-                const instance = container.get(service, { optional: true });
-                if (instance != null && typeof instance === 'object') {
-                    // 检查实例是否实现了 Service 接口
-                    if ('init' in instance && typeof instance.init === 'function') {
-                        // 检查是否已经初始化
-                        if (instance.inited == false) {
-                            // 安全地调用 init 方法，捕获可能的异常
-                            const result = await catchIt(() => instance.init());
-                            // 使用 runInAction 确保状态更新被 Mobx 正确跟踪
-                            runInAction(() => instance.inited = !result.isError());
-                        }
+        const initPromises = services.map(async (service) => {
+            // 尝试从容器中获取服务实例（可选的，避免未注册时报错）
+            const instance = container.get(service, { optional: true });
+            if (instance != null && typeof instance === 'object') {
+                // 检查实例是否实现了 Service 接口
+                if ('init' in instance && typeof instance.init === 'function') {
+                    if (instance.inited !== true) {
+                        await initializeServiceInstance(instance).catch((error) => {
+                            if (error instanceof InvalidInitReturnError && !disposed) {
+                                setInitError(error);
+                            }
+                        });
                     }
                 }
-            });
-            // 等待所有服务初始化完成
-            await Promise.all(initPromises);
-        })();
+            }
+        });
+        void Promise.all(initPromises);
+        return () => {
+            disposed = true;
+        };
     }, [container, services]);
+    if (initError) {
+        throw initError;
+    }
     return children;
 }

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, 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;
@@ -369,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('应该能够渲染子组件', () => {
@@ -446,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 的情况', () => {
@@ -630,6 +906,52 @@ describe('service integration', () => {
                 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 => ({
@@ -756,6 +1078,198 @@ describe('service integration', () => {
             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 () => {
@@ -831,5 +1345,55 @@ describe('service integration', () => {
                 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');
+            });
+        });
     });
 });

package/package.json

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