@taicode/common-web 1.1.10 → 1.1.13

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;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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;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;;;;;OAKG;IACH,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAA;IAC7B,UAAU;IACV,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,6CAA6C;AAE7C,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,8EA2B1D"}

package/output/service/service.js

@@ -196,12 +196,14 @@ export function useLocalService(ServiceClass, selector) {
  * 特性：
  * - 自动复用父级容器，避免重复创建
  * - 支持容器层级结构，子容器可以覆盖父容器的服务
- * - 自动初始化实现了 Service 接口的服务
+ * - 支持两种注入方式：类注入和值注入
+ * - 自动初始化实现了 Service 接口的服务（仅限类注入）
  *
  * @param props 组件属性
  *
  * @example
  * ```tsx
+ * // 方式 1: 类注入 - 自动实例化和初始化
  * function App() {
  *   return (
  *     <ServiceProvider services={[UserService, ProductService]}>
@@ -215,11 +217,53 @@ export function useLocalService(ServiceClass, selector) {
  *   )
  * }
  *
- * // 嵌套服务提供者
+ * // 方式 2: 值注入 - 在多个组件间共享局部服务实例
  * function UserPage() {
+ *   // 创建局部服务实例
+ *   const localUserService = useMemo(() => {
+ *     const service = new LocalUserService()
+ *     service.init() // 手动初始化
+ *     return service
+ *   }, [])
+ *
  *   return (
- *     <ServiceProvider services={[LocalUserService]}>
+ *     <ServiceProvider
+ *       services={[
+ *         { provide: LocalUserService, useValue: localUserService }
+ *       ]}
+ *     >
  *       <UserList />
+ *       <UserDetail />
+ *     </ServiceProvider>
+ *   )
+ * }
+ *
+ * // UserList 和 UserDetail 共享同一个 localUserService 实例
+ * function UserList() {
+ *   const users = useService(LocalUserService, s => s.users)
+ *   return <div>{users.length} users</div>
+ * }
+ *
+ * function UserDetail() {
+ *   const service = useService(LocalUserService)
+ *   return <div>{service.currentUser?.name}</div>
+ * }
+ *
+ * // 方式 3: 混合使用类注入和值注入
+ * function App() {
+ *   const configService = useMemo(() => {
+ *     const config = new ConfigService()
+ *     config.loadConfig() // 预配置
+ *     return config
+ *   }, [])
+ *
+ *   return (
+ *     <ServiceProvider services={[
+ *       UserService,  // 类注入 - 自动实例化和初始化
+ *       ApiService,   // 类注入
+ *       { provide: ConfigService, useValue: configService }  // 值注入 - 使用预配置的实例
+ *     ]}>
+ *       <Router />
  *     </ServiceProvider>
  *   )
  * }
@@ -233,9 +277,11 @@ export function ServiceProvider(props) {
     // 创建子容器，复用父容器的服务配置
     const container = useMemo(() => {
         const currentContainer = new Container(parentContainer);
-        const typed = services;
-        currentContainer.bindAll(...typed); // 批量绑定服务到容器
-        // bindAll 要求参数必须是元组类型
+        // 直接绑定所有服务（包括类注入和值注入）
+        // needle-di 的 bind 方法可以处理所有类型的 Provider
+        services.forEach(service => {
+            currentContainer.bind(service);
+        });
         return currentContainer;
     }, [parentContainer, services]);
     // 使用 React.createElement 避免将文件改为 .tsx
@@ -249,10 +295,15 @@ export function ServiceProvider(props) {
  * 它会在组件挂载时检查每个服务是否需要初始化，并调用其 init 方法。
  *
  * 初始化流程：
- * 1. 从容器中获取服务实例
- * 2. 检查服务是否实现了 Service 接口（有 init 方法）
- * 3. 检查服务是否已经初始化（inited 属性）
- * 4. 如果未初始化，则调用 init 方法并更新状态
+ * 1. 跳过值注入的服务（它们应该在传入前已经初始化）
+ * 2. 从容器中获取服务实例（仅类注入的服务）
+ * 3. 检查服务是否实现了 Service 接口（有 init 方法）
+ * 4. 检查服务是否已经初始化（inited 属性）
+ * 5. 如果未初始化，则调用 init 方法并更新状态
+ *
+ * 注意：
+ * - 值注入的服务需要在传入前手动初始化
+ * - 只有类注入的服务会自动调用 init 方法
  *
  * @param props 组件属性，与 ServiceProviderProps 相同
  */
@@ -269,6 +320,10 @@ function InitService(props) {
         setInitError(prev => (prev === null ? prev : null));
         // 异步初始化所有服务
         const initPromises = services.map(async (service) => {
+            // 跳过值注入的服务（它们应该在传入前已经初始化）
+            if (service != null && typeof service === 'object' && 'provide' in service && 'useValue' in service) {
+                return;
+            }
             // 尝试从容器中获取服务实例（可选的，避免未注册时报错）
             const instance = container.get(service, { optional: true });
             if (instance != null && typeof instance === 'object') {

package/output/service/service.test.jsx

@@ -0,0 +1,367 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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';
+// 创建测试用的服务类
+let TestService = (() => {
+    var _a, _TestService_count_accessor_storage, _TestService_users_accessor_storage, _TestService_inited_accessor_storage;
+    let _classSuper = Service;
+    let _instanceExtraInitializers = [];
+    let _count_decorators;
+    let _count_initializers = [];
+    let _count_extraInitializers = [];
+    let _users_decorators;
+    let _users_initializers = [];
+    let _users_extraInitializers = [];
+    let _inited_decorators;
+    let _inited_initializers = [];
+    let _inited_extraInitializers = [];
+    let _increment_decorators;
+    let _addUser_decorators;
+    return _a = class TestService extends _classSuper {
+            get count() { return __classPrivateFieldGet(this, _TestService_count_accessor_storage, "f"); }
+            set count(value) { __classPrivateFieldSet(this, _TestService_count_accessor_storage, value, "f"); }
+            get users() { return __classPrivateFieldGet(this, _TestService_users_accessor_storage, "f"); }
+            set users(value) { __classPrivateFieldSet(this, _TestService_users_accessor_storage, value, "f"); }
+            get inited() { return __classPrivateFieldGet(this, _TestService_inited_accessor_storage, "f"); }
+            set inited(value) { __classPrivateFieldSet(this, _TestService_inited_accessor_storage, value, "f"); }
+            constructor() {
+                super();
+                _TestService_count_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _count_initializers, 0)));
+                _TestService_users_accessor_storage.set(this, (__runInitializers(this, _count_extraInitializers), __runInitializers(this, _users_initializers, [])));
+                _TestService_inited_accessor_storage.set(this, (__runInitializers(this, _users_extraInitializers), __runInitializers(this, _inited_initializers, false)));
+                __runInitializers(this, _inited_extraInitializers);
+                makeObservable(this);
+            }
+            async init() {
+                runInAction(() => {
+                    this.users = ['Alice', 'Bob'];
+                });
+                return true;
+            }
+            increment() {
+                this.count++;
+            }
+            addUser(name) {
+                this.users.push(name);
+            }
+        },
+        _TestService_count_accessor_storage = new WeakMap(),
+        _TestService_users_accessor_storage = new WeakMap(),
+        _TestService_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;
+            _count_decorators = [observable];
+            _users_decorators = [observable];
+            _inited_decorators = [observable];
+            _increment_decorators = [action];
+            _addUser_decorators = [action];
+            __esDecorate(_a, null, _count_decorators, { kind: "accessor", name: "count", static: false, private: false, access: { has: obj => "count" in obj, get: obj => obj.count, set: (obj, value) => { obj.count = value; } }, metadata: _metadata }, _count_initializers, _count_extraInitializers);
+            __esDecorate(_a, null, _users_decorators, { kind: "accessor", name: "users", static: false, private: false, access: { has: obj => "users" in obj, get: obj => obj.users, set: (obj, value) => { obj.users = value; } }, metadata: _metadata }, _users_initializers, _users_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, _addUser_decorators, { kind: "method", name: "addUser", static: false, private: false, access: { has: obj => "addUser" in obj, get: obj => obj.addUser }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+// 另一个测试服务类
+let AnotherService = (() => {
+    var _a, _AnotherService_value_accessor_storage;
+    let _instanceExtraInitializers = [];
+    let _value_decorators;
+    let _value_initializers = [];
+    let _value_extraInitializers = [];
+    let _setValue_decorators;
+    return _a = class AnotherService {
+            get value() { return __classPrivateFieldGet(this, _AnotherService_value_accessor_storage, "f"); }
+            set value(value) { __classPrivateFieldSet(this, _AnotherService_value_accessor_storage, value, "f"); }
+            constructor() {
+                _AnotherService_value_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _value_initializers, 'initial')));
+                __runInitializers(this, _value_extraInitializers);
+                makeObservable(this);
+            }
+            setValue(newValue) {
+                this.value = newValue;
+            }
+        },
+        _AnotherService_value_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _value_decorators = [observable];
+            _setValue_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, _setValue_decorators, { kind: "method", name: "setValue", static: false, private: false, access: { has: obj => "setValue" in obj, get: obj => obj.setValue }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+// 没有 init 方法的服务类
+let SimpleService = (() => {
+    var _a, _SimpleService_data_accessor_storage;
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
+    return _a = class SimpleService {
+            get data() { return __classPrivateFieldGet(this, _SimpleService_data_accessor_storage, "f"); }
+            set data(value) { __classPrivateFieldSet(this, _SimpleService_data_accessor_storage, value, "f"); }
+            constructor() {
+                _SimpleService_data_accessor_storage.set(this, __runInitializers(this, _data_initializers, 'simple'));
+                __runInitializers(this, _data_extraInitializers);
+                makeObservable(this);
+            }
+        },
+        _SimpleService_data_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _data_decorators = [observable];
+            __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);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+// 创建测试用的 Provider 组件
+function createTestProvider(services) {
+    return function TestProvider({ children }) {
+        return (<ServiceProvider services={services}>
+        {children}
+      </ServiceProvider>);
+    };
+}
+describe('service integration', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('useService', () => {
+        it('应该能够获取服务实例并选择数据', () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useService(TestService, service => service.count), { wrapper: TestProvider });
+            expect(result.current).toBe(0);
+        });
+        it('应该在服务数据变化时触发重新渲染', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                count: useService(TestService, service => service.count),
+                service: useService(TestService, service => service)
+            }), { wrapper: TestProvider });
+            expect(result.current.count).toBe(0);
+            // 修改服务数据
+            act(() => {
+                result.current.service.increment();
+            });
+            await waitFor(() => {
+                expect(result.current.count).toBe(1);
+            });
+        });
+        it('应该能够选择复杂数据结构', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => ({
+                userCount: useService(TestService, service => service.users.length),
+                service: useService(TestService, service => service)
+            }), { wrapper: TestProvider });
+            // 等待初始化完成
+            await waitFor(() => {
+                expect(result.current.userCount).toBe(2);
+            });
+            // 添加新用户
+            act(() => {
+                result.current.service.addUser('Charlie');
+            });
+            await waitFor(() => {
+                expect(result.current.userCount).toBe(3);
+            });
+        });
+        it('应该在没有 ServiceProvider 时抛出错误', () => {
+            expect(() => {
+                renderHook(() => useService(TestService, service => service.count));
+            }).toThrow('Must be a child of ServiceProvider.');
+        });
+        it('应该能够处理多个服务', () => {
+            const TestProvider = createTestProvider([TestService, AnotherService]);
+            const { result } = renderHook(() => ({
+                count: useService(TestService, service => service.count),
+                value: useService(AnotherService, service => service.value)
+            }), { wrapper: TestProvider });
+            expect(result.current.count).toBe(0);
+            expect(result.current.value).toBe('initial');
+        });
+    });
+    describe('ServiceProvider', () => {
+        it('应该能够渲染子组件', () => {
+            const { container } = render(<ServiceProvider services={[TestService]}>
+          <div data-testid="child">Test Child</div>
+        </ServiceProvider>);
+            expect(container.querySelector('[data-testid="child"]')).toBeTruthy();
+        });
+        it('应该能够嵌套使用', () => {
+            const ParentProvider = createTestProvider([TestService]);
+            const ChildProvider = createTestProvider([AnotherService]);
+            const { result } = renderHook(() => ({
+                count: useService(TestService, service => service.count),
+                value: useService(AnotherService, service => service.value)
+            }), {
+                wrapper: ({ children }) => (<ParentProvider>
+              <ChildProvider>
+                {children}
+              </ChildProvider>
+            </ParentProvider>)
+            });
+            expect(result.current.count).toBe(0);
+            expect(result.current.value).toBe('initial');
+        });
+        it('应该自动初始化实现了 Service 接口的服务', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useService(TestService, service => ({
+                users: service.users,
+                inited: service.inited
+            })), { wrapper: TestProvider });
+            // 等待初始化完成
+            await waitFor(() => {
+                expect(result.current.inited).toBe(true);
+                expect(result.current.users).toEqual(['Alice', 'Bob']);
+            });
+        });
+        it('应该能够处理没有 init 方法的服务', () => {
+            const TestProvider = createTestProvider([SimpleService]);
+            const { result } = renderHook(() => useService(SimpleService, service => service.data), { wrapper: TestProvider });
+            expect(result.current).toBe('simple');
+        });
+        it('应该能够处理空的服务数组', () => {
+            const { container } = render(<ServiceProvider services={[]}>
+          <div data-testid="child">Test Child</div>
+        </ServiceProvider>);
+            expect(container.querySelector('[data-testid="child"]')).toBeTruthy();
+        });
+        it('应该能够处理初始化失败的服务', async () => {
+            // 创建一个初始化会失败的服务
+            let FailingService = (() => {
+                var _a, _FailingService_inited_accessor_storage;
+                let _classSuper = Service;
+                let _inited_decorators;
+                let _inited_initializers = [];
+                let _inited_extraInitializers = [];
+                return _a = class FailingService extends _classSuper {
+                        get inited() { return __classPrivateFieldGet(this, _FailingService_inited_accessor_storage, "f"); }
+                        set inited(value) { __classPrivateFieldSet(this, _FailingService_inited_accessor_storage, value, "f"); }
+                        constructor() {
+                            super();
+                            _FailingService_inited_accessor_storage.set(this, __runInitializers(this, _inited_initializers, false));
+                            __runInitializers(this, _inited_extraInitializers);
+                            makeObservable(this);
+                        }
+                        async init() {
+                            throw new Error('Init failed');
+                        }
+                    },
+                    _FailingService_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([FailingService]);
+            const { result } = renderHook(() => useService(FailingService, service => service.inited), { wrapper: TestProvider });
+            // 等待初始化处理完成，即使失败也应该保持 inited 为 false
+            await waitFor(() => {
+                expect(result.current).toBe(false); // 因为初始化失败，inited 应该保持 false
+            });
+        });
+    });
+    describe('边界情况', () => {
+        it('useService 应该能够处理选择器返回 undefined 的情况', () => {
+            const TestProvider = createTestProvider([TestService]);
+            const { result } = renderHook(() => useService(TestService, () => undefined), { wrapper: TestProvider });
+            expect(result.current).toBeUndefined();
+        });
+        it('应该能够处理 selector 函数变化的情况', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            let useCount = true;
+            const { result, rerender } = renderHook(() => ({
+                selected: useService(TestService, service => useCount ? service.count : service.users.length),
+                service: useService(TestService, service => service)
+            }), { wrapper: TestProvider });
+            expect(result.current.selected).toBe(0);
+            // 修改 selector
+            useCount = false;
+            rerender();
+            await waitFor(() => {
+                expect(result.current.selected).toBe(2); // users 初始化后包含 ['Alice', 'Bob']，长度为 2
+            });
+        });
+    });
+    describe('性能测试', () => {
+        it('useService 应该在 selector 返回相同值时不触发重渲染', async () => {
+            const TestProvider = createTestProvider([TestService]);
+            let renderCount = 0;
+            const { result } = renderHook(() => {
+                renderCount++;
+                return {
+                    constValue: useService(TestService, () => 'constant'),
+                    service: useService(TestService, service => service)
+                };
+            }, { wrapper: TestProvider });
+            const initialRenderCount = renderCount;
+            // 修改服务但选择器返回常量
+            act(() => {
+                result.current.service.increment();
+            });
+            // 等待一段时间确保没有额外渲染
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 由于选择器返回常量，理论上不应该有额外渲染
+            // 但 Mobx reaction 的具体行为可能会有差异
+            expect(renderCount).toBeGreaterThanOrEqual(initialRenderCount);
+        });
+    });
+});

package/output/toaster/index.d.ts

@@ -8,5 +8,11 @@ interface ToastCatcherProps {
 }
 /** 自动捕获和处理异步错误，无法识别的错误会保持原样 */
 export declare function Toaster(props: ToastCatcherProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Toaster {
+    var info: (content: React.ReactNode) => void;
+    var error: (content: React.ReactNode) => void;
+    var success: (content: React.ReactNode) => void;
+    var warning: (content: React.ReactNode) => void;
+}
 export {};
 //# sourceMappingURL=index.d.ts.map

package/output/toaster/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/toaster/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyC,MAAM,OAAO,CAAA;AAE7D,OAAO,EAA0B,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAE7F,OAAO,uCAAuC,CAAA;AAE9C,UAAU,iBAAiB;IACzB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,GAAG,eAAe,EAAE,MAAM,CAAC,CAAC,CAAA;CACnE;AAED,+BAA+B;AAC/B,wBAAgB,OAAO,CAAC,KAAK,EAAE,iBAAiB,2CA2F/C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/toaster/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyC,MAAM,OAAO,CAAA;AAE7D,OAAO,EAA0B,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAE7F,OAAO,uCAAuC,CAAA;AAE9C,UAAU,iBAAiB;IACzB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,GAAG,eAAe,EAAE,MAAM,CAAC,CAAC,CAAA;CACnE;AAED,+BAA+B;AAC/B,wBAAgB,OAAO,CAAC,KAAK,EAAE,iBAAiB,2CAyF/C;yBAzFe,OAAO;wBAmGE,KAAK,CAAC,SAAS;yBAId,KAAK,CAAC,SAAS;2BAIb,KAAK,CAAC,SAAS;2BAIf,KAAK,CAAC,SAAS"}

package/output/toaster/index.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useRef } from 'react';
+import { useEffect, useRef } from 'react';
 import { ToastContainer, toast as baseToast } from 'react-toastify';
 import { SystemError, UserError } from '@taicode/common-base';
 import 'react-toastify/dist/ReactToastify.css';
@@ -7,35 +7,42 @@ import 'react-toastify/dist/ReactToastify.css';
 export function Toaster(props) {
     const addEventListened = useRef(false);
     const { messages = {}, defaultMessage } = props;
-    const sendError = useCallback((error) => {
-        baseToast.error(_jsx(Toast, { type: 'error', error: error }), {
-            className: 'p-0 w-[400px] border-0',
-            closeButton: false,
-        });
-    }, []);
-    const sendSuccess = useCallback((error) => {
-        baseToast.error(_jsx(Toast, { type: 'error', error: error }), {
-            className: 'p-0 w-[400px] border-0',
-            closeButton: false,
-        });
-    }, []);
+    const handledErrors = useRef(new WeakSet());
     useEffect(() => {
         if (addEventListened.current)
             return;
         const errorHandler = (event) => {
             const errorObject = event.error;
+            // 检查是否已经处理过这个错误对象
+            if (errorObject && handledErrors.current.has(errorObject)) {
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
             if (SystemError.is(errorObject) || UserError.is(errorObject)) {
+                console.error('Caught error:', errorObject);
+                // 标记此错误已处理
+                handledErrors.current.add(errorObject);
                 event.preventDefault();
                 event.stopPropagation();
-                sendError(errorObject.type);
+                Toaster.error(messages[errorObject.type] || defaultMessage);
             }
         };
         const unhandledRejectionHandler = (event) => {
             const errorObject = event.reason;
+            // 检查是否已经处理过这个错误对象
+            if (errorObject && handledErrors.current.has(errorObject)) {
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
             if (SystemError.is(errorObject) || UserError.is(errorObject)) {
+                console.error('Caught error:', errorObject);
+                // 标记此错误已处理
+                handledErrors.current.add(errorObject);
                 event.preventDefault();
                 event.stopPropagation();
-                sendError(errorObject.type);
+                Toaster.error(messages[errorObject.type] || defaultMessage);
             }
         };
         window.addEventListener('error', errorHandler, true);
@@ -45,17 +52,26 @@ export function Toaster(props) {
             window.removeEventListener('error', errorHandler, true);
             window.removeEventListener('unhandledrejection', unhandledRejectionHandler, true);
             addEventListened.current = false;
+            handledErrors.current = new WeakSet();
         };
     }, []);
     return (_jsxs(_Fragment, { children: [props.children, _jsx(ToastContainer, { newestOnTop: true, hideProgressBar: true, closeButton: false, position: "top-center" })] }));
     function ErrorIcon() {
         return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 24 24", strokeWidth: 1.5, stroke: "currentColor", className: "size-6 text-red-500", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "m9.75 9.75 4.5 4.5m0-4.5-4.5 4.5M21 12a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" }) }));
     }
-    function SuccessIcon() {
-        return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 24 24", strokeWidth: 1.5, stroke: "currentColor", className: "size-6 text-green-500", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M9 12.75 11.25 15 15 9.75M21 12a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" }) }));
-    }
-    function Toast(props) {
-        const { type, error } = props;
-        return (_jsxs("div", { className: "flex items-center w-full p-4 space-x-4 rtl:space-x-reverse text-gray-500 bg-white divide-x rtl:divide-x-reverse divide-gray-200 rounded-lg shadow dark:text-gray-400 dark:divide-gray-700 dark:bg-gray-800", role: "alert", children: [props.type === 'error' && (_jsx(ErrorIcon, {})), props.type === 'success' && (_jsx(SuccessIcon, {})), _jsx("div", { className: "ps-4 text-sm font-normal", children: messages[error] || defaultMessage })] }));
+    function ErrorToast(props) {
+        return (_jsxs("div", { className: "flex items-center space-x-3", role: "alert", children: [_jsx(ErrorIcon, {}), _jsx("div", { className: "text-sm font-medium text-gray-900 dark:text-gray-100" })] }));
     }
 }
+Toaster.info = (content) => {
+    baseToast.info(content);
+};
+Toaster.error = (content) => {
+    baseToast.error(content);
+};
+Toaster.success = (content) => {
+    baseToast.success(content);
+};
+Toaster.warning = (content) => {
+    baseToast.warning(content);
+};