@lee-zg/melange 1.2.3 → 1.2.5

package/dist/container-B8n-ok8M.d.cts

@@ -0,0 +1,201 @@
+import { C as Constructor } from './types-BtOUCLB-.cjs';
+
+/**
+ * @fileoverview 依赖注入容器
+ * @module melange/core/container
+ * @description 提供一个简单而强大的依赖注入容器
+ * 支持单例、工厂函数和自动解析。
+ */
+
+/**
+ * 用于标识依赖项的令牌类型。
+ * 可以是字符串、符号或类构造函数。
+ */
+type Token<T = unknown> = string | symbol | Constructor<T>;
+/**
+ * 创建实例的工厂函数类型。
+ */
+type Factory<T> = (container: Container) => T;
+/**
+ * 依赖注册的生命周期选项。
+ */
+declare enum Lifecycle {
+    /** 每次都创建新实例 */
+    Transient = "transient",
+    /** 创建单个实例并重复使用 */
+    Singleton = "singleton"
+}
+/**
+ * 依赖注入容器。
+ * 管理依赖项的生命周期和解析。
+ *
+ * @description
+ * Container 类提供控制反转 (IoC) 功能，
+ * 允许您通过在运行时注册和解析依赖项来解耦代码。
+ *
+ * @example
+ * ```typescript
+ * // 创建容器
+ * const container = new Container();
+ *
+ * // 注册类
+ * container.register('logger', () => new ConsoleLogger());
+ *
+ * // 注册单例
+ * container.registerSingleton('config', () => loadConfig());
+ *
+ * // 解析依赖项
+ * const logger = container.resolve<Logger>('logger');
+ *
+ * // 使用装饰器
+ * @Injectable()
+ * class UserService {
+ *   constructor(@Inject('logger') private logger: Logger) {}
+ * }
+ * container.registerClass(UserService);
+ * ```
+ */
+declare class Container {
+    /**
+     * 已注册依赖项的映射
+     */
+    private registrations;
+    /**
+     * 用于分层解析的父容器
+     */
+    private parent;
+    /**
+     * 创建新的容器实例。
+     *
+     * @param parent - 用于分层解析的可选父容器
+     */
+    constructor(parent?: Container);
+    /**
+     * 使用工厂函数注册依赖项。
+     *
+     * @template T - 依赖项类型
+     * @param token - 用于标识依赖项的令牌
+     * @param factory - 创建依赖项的工厂函数
+     * @param lifecycle - 依赖项的生命周期（默认：Transient）
+     * @returns 容器实例，用于链式调用
+     */
+    register<T>(token: Token<T>, factory: Factory<T>, lifecycle?: Lifecycle): this;
+    /**
+     * 注册单例依赖项。
+     * 工厂函数只会被调用一次，之后返回相同的实例。
+     *
+     * @template T - 依赖项类型
+     * @param token - 用于标识依赖项的令牌
+     * @param factory - 创建依赖项的工厂函数
+     * @returns 容器实例，用于链式调用
+     */
+    registerSingleton<T>(token: Token<T>, factory: Factory<T>): this;
+    /**
+     * 直接将值注册为单例。
+     *
+     * @template T - 值类型
+     * @param token - 用于标识依赖项的令牌
+     * @param value - 要注册的值
+     * @returns 容器实例，用于链式调用
+     */
+    registerValue<T>(token: Token<T>, value: T): this;
+    /**
+     * 将类注册为依赖项。
+     * 类的实例化会自动解析其依赖项。
+     *
+     * @template T - 类类型
+     * @param ClassConstructor - 要注册的类构造函数
+     * @param lifecycle - 依赖项的生命周期（默认：Transient）
+     * @returns 容器实例，用于链式调用
+     */
+    registerClass<T extends object>(ClassConstructor: Constructor<T>, lifecycle?: Lifecycle): this;
+    /**
+     * 通过令牌解析依赖项。
+     *
+     * @template T - 依赖项类型
+     * @param token - 标识依赖项的令牌
+     * @returns 已解析的依赖项
+     * @throws Error 如果依赖项未注册
+     */
+    resolve<T>(token: Token<T>): T;
+    /**
+     * 检查依赖项是否已注册。
+     *
+     * @param token - 要检查的令牌
+     * @returns 如果依赖项已注册则返回 true
+     */
+    has(token: Token): boolean;
+    /**
+     * 移除依赖项注册。
+     *
+     * @param token - 要移除的令牌
+     * @returns 如果注册已被移除则返回 true
+     */
+    unregister(token: Token): boolean;
+    /**
+     * 清除所有注册。
+     */
+    clear(): void;
+    /**
+     * 创建子容器。
+     * 子容器从父容器继承注册。
+     *
+     * @returns 新的子容器
+     */
+    createChild(): Container;
+    /**
+     * 获取类的注入元数据。
+     */
+    private getInjectMetadata;
+}
+/**
+ * 为了方便而提供的全局容器实例。
+ */
+declare const globalContainer: Container;
+/**
+ * 将类标记为可注入。
+ * 自动依赖解析所必需。
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   constructor(private userRepo: UserRepository) {}
+ * }
+ * ```
+ *
+ * @returns 类装饰器
+ */
+declare function Injectable(): ClassDecorator;
+/**
+ * 标记构造函数参数以进行注入。
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   constructor(@Inject('logger') private logger: Logger) {}
+ * }
+ * ```
+ *
+ * @param token - 要注入的令牌
+ * @returns 参数装饰器
+ */
+declare function Inject(token: Token): ParameterDecorator;
+/**
+ * 将类标记为单例。
+ * 结合 @Injectable 和单例生命周期。
+ *
+ * @example
+ * ```typescript
+ * @Singleton()
+ * class ConfigService {
+ *   // 只会存在一个实例
+ * }
+ * ```
+ *
+ * @returns 类装饰器
+ */
+declare function Singleton(): ClassDecorator;
+
+export { Container as C, type Factory as F, Injectable as I, Lifecycle as L, Singleton as S, type Token as T, Inject as a, globalContainer as g };

package/dist/container-n8Q2Xa_y.d.ts

@@ -0,0 +1,201 @@
+import { C as Constructor } from './types-BtOUCLB-.js';
+
+/**
+ * @fileoverview 依赖注入容器
+ * @module melange/core/container
+ * @description 提供一个简单而强大的依赖注入容器
+ * 支持单例、工厂函数和自动解析。
+ */
+
+/**
+ * 用于标识依赖项的令牌类型。
+ * 可以是字符串、符号或类构造函数。
+ */
+type Token<T = unknown> = string | symbol | Constructor<T>;
+/**
+ * 创建实例的工厂函数类型。
+ */
+type Factory<T> = (container: Container) => T;
+/**
+ * 依赖注册的生命周期选项。
+ */
+declare enum Lifecycle {
+    /** 每次都创建新实例 */
+    Transient = "transient",
+    /** 创建单个实例并重复使用 */
+    Singleton = "singleton"
+}
+/**
+ * 依赖注入容器。
+ * 管理依赖项的生命周期和解析。
+ *
+ * @description
+ * Container 类提供控制反转 (IoC) 功能，
+ * 允许您通过在运行时注册和解析依赖项来解耦代码。
+ *
+ * @example
+ * ```typescript
+ * // 创建容器
+ * const container = new Container();
+ *
+ * // 注册类
+ * container.register('logger', () => new ConsoleLogger());
+ *
+ * // 注册单例
+ * container.registerSingleton('config', () => loadConfig());
+ *
+ * // 解析依赖项
+ * const logger = container.resolve<Logger>('logger');
+ *
+ * // 使用装饰器
+ * @Injectable()
+ * class UserService {
+ *   constructor(@Inject('logger') private logger: Logger) {}
+ * }
+ * container.registerClass(UserService);
+ * ```
+ */
+declare class Container {
+    /**
+     * 已注册依赖项的映射
+     */
+    private registrations;
+    /**
+     * 用于分层解析的父容器
+     */
+    private parent;
+    /**
+     * 创建新的容器实例。
+     *
+     * @param parent - 用于分层解析的可选父容器
+     */
+    constructor(parent?: Container);
+    /**
+     * 使用工厂函数注册依赖项。
+     *
+     * @template T - 依赖项类型
+     * @param token - 用于标识依赖项的令牌
+     * @param factory - 创建依赖项的工厂函数
+     * @param lifecycle - 依赖项的生命周期（默认：Transient）
+     * @returns 容器实例，用于链式调用
+     */
+    register<T>(token: Token<T>, factory: Factory<T>, lifecycle?: Lifecycle): this;
+    /**
+     * 注册单例依赖项。
+     * 工厂函数只会被调用一次，之后返回相同的实例。
+     *
+     * @template T - 依赖项类型
+     * @param token - 用于标识依赖项的令牌
+     * @param factory - 创建依赖项的工厂函数
+     * @returns 容器实例，用于链式调用
+     */
+    registerSingleton<T>(token: Token<T>, factory: Factory<T>): this;
+    /**
+     * 直接将值注册为单例。
+     *
+     * @template T - 值类型
+     * @param token - 用于标识依赖项的令牌
+     * @param value - 要注册的值
+     * @returns 容器实例，用于链式调用
+     */
+    registerValue<T>(token: Token<T>, value: T): this;
+    /**
+     * 将类注册为依赖项。
+     * 类的实例化会自动解析其依赖项。
+     *
+     * @template T - 类类型
+     * @param ClassConstructor - 要注册的类构造函数
+     * @param lifecycle - 依赖项的生命周期（默认：Transient）
+     * @returns 容器实例，用于链式调用
+     */
+    registerClass<T extends object>(ClassConstructor: Constructor<T>, lifecycle?: Lifecycle): this;
+    /**
+     * 通过令牌解析依赖项。
+     *
+     * @template T - 依赖项类型
+     * @param token - 标识依赖项的令牌
+     * @returns 已解析的依赖项
+     * @throws Error 如果依赖项未注册
+     */
+    resolve<T>(token: Token<T>): T;
+    /**
+     * 检查依赖项是否已注册。
+     *
+     * @param token - 要检查的令牌
+     * @returns 如果依赖项已注册则返回 true
+     */
+    has(token: Token): boolean;
+    /**
+     * 移除依赖项注册。
+     *
+     * @param token - 要移除的令牌
+     * @returns 如果注册已被移除则返回 true
+     */
+    unregister(token: Token): boolean;
+    /**
+     * 清除所有注册。
+     */
+    clear(): void;
+    /**
+     * 创建子容器。
+     * 子容器从父容器继承注册。
+     *
+     * @returns 新的子容器
+     */
+    createChild(): Container;
+    /**
+     * 获取类的注入元数据。
+     */
+    private getInjectMetadata;
+}
+/**
+ * 为了方便而提供的全局容器实例。
+ */
+declare const globalContainer: Container;
+/**
+ * 将类标记为可注入。
+ * 自动依赖解析所必需。
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   constructor(private userRepo: UserRepository) {}
+ * }
+ * ```
+ *
+ * @returns 类装饰器
+ */
+declare function Injectable(): ClassDecorator;
+/**
+ * 标记构造函数参数以进行注入。
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   constructor(@Inject('logger') private logger: Logger) {}
+ * }
+ * ```
+ *
+ * @param token - 要注入的令牌
+ * @returns 参数装饰器
+ */
+declare function Inject(token: Token): ParameterDecorator;
+/**
+ * 将类标记为单例。
+ * 结合 @Injectable 和单例生命周期。
+ *
+ * @example
+ * ```typescript
+ * @Singleton()
+ * class ConfigService {
+ *   // 只会存在一个实例
+ * }
+ * ```
+ *
+ * @returns 类装饰器
+ */
+declare function Singleton(): ClassDecorator;
+
+export { Container as C, type Factory as F, Injectable as I, Lifecycle as L, Singleton as S, type Token as T, Inject as a, globalContainer as g };

package/dist/core/index.d.cts

@@ -1,4 +1,5 @@
-import { v as EventHandler, x as Subscription, C as Constructor } from '../types-BtOUCLB-.cjs';
+import { v as EventHandler, x as Subscription } from '../types-BtOUCLB-.cjs';
+export { C as Container, F as Factory, a as Inject, I as Injectable, L as Lifecycle, S as Singleton, T as Token, g as globalContainer } from '../container-B8n-ok8M.cjs';
 
 /**
  * @fileoverview 用于发布/订阅模式的事件发射器类
@@ -125,204 +126,6 @@ declare class EventEmitter<Events extends EventMap = EventMap> {
     private addListener;
 }
 
-/**
- * @fileoverview 依赖注入容器
- * @module melange/core/container
- * @description 提供一个简单而强大的依赖注入容器
- * 支持单例、工厂函数和自动解析。
- */
-
-/**
- * 用于标识依赖项的令牌类型。
- * 可以是字符串、符号或类构造函数。
- */
-type Token<T = unknown> = string | symbol | Constructor<T>;
-/**
- * 创建实例的工厂函数类型。
- */
-type Factory<T> = (container: Container) => T;
-/**
- * 依赖注册的生命周期选项。
- */
-declare enum Lifecycle {
-    /** 每次都创建新实例 */
-    Transient = "transient",
-    /** 创建单个实例并重复使用 */
-    Singleton = "singleton"
-}
-/**
- * 依赖注入容器。
- * 管理依赖项的生命周期和解析。
- *
- * @description
- * Container 类提供控制反转 (IoC) 功能，
- * 允许您通过在运行时注册和解析依赖项来解耦代码。
- *
- * @example
- * ```typescript
- * // 创建容器
- * const container = new Container();
- *
- * // 注册类
- * container.register('logger', () => new ConsoleLogger());
- *
- * // 注册单例
- * container.registerSingleton('config', () => loadConfig());
- *
- * // 解析依赖项
- * const logger = container.resolve<Logger>('logger');
- *
- * // 使用装饰器
- * @Injectable()
- * class UserService {
- *   constructor(@Inject('logger') private logger: Logger) {}
- * }
- * container.registerClass(UserService);
- * ```
- */
-declare class Container {
-    /**
-     * 已注册依赖项的映射
-     */
-    private registrations;
-    /**
-     * 用于分层解析的父容器
-     */
-    private parent;
-    /**
-     * 创建新的容器实例。
-     *
-     * @param parent - 用于分层解析的可选父容器
-     */
-    constructor(parent?: Container);
-    /**
-     * 使用工厂函数注册依赖项。
-     *
-     * @template T - 依赖项类型
-     * @param token - 用于标识依赖项的令牌
-     * @param factory - 创建依赖项的工厂函数
-     * @param lifecycle - 依赖项的生命周期（默认：Transient）
-     * @returns 容器实例，用于链式调用
-     */
-    register<T>(token: Token<T>, factory: Factory<T>, lifecycle?: Lifecycle): this;
-    /**
-     * 注册单例依赖项。
-     * 工厂函数只会被调用一次，之后返回相同的实例。
-     *
-     * @template T - 依赖项类型
-     * @param token - 用于标识依赖项的令牌
-     * @param factory - 创建依赖项的工厂函数
-     * @returns 容器实例，用于链式调用
-     */
-    registerSingleton<T>(token: Token<T>, factory: Factory<T>): this;
-    /**
-     * 直接将值注册为单例。
-     *
-     * @template T - 值类型
-     * @param token - 用于标识依赖项的令牌
-     * @param value - 要注册的值
-     * @returns 容器实例，用于链式调用
-     */
-    registerValue<T>(token: Token<T>, value: T): this;
-    /**
-     * 将类注册为依赖项。
-     * 类的实例化会自动解析其依赖项。
-     *
-     * @template T - 类类型
-     * @param ClassConstructor - 要注册的类构造函数
-     * @param lifecycle - 依赖项的生命周期（默认：Transient）
-     * @returns 容器实例，用于链式调用
-     */
-    registerClass<T extends object>(ClassConstructor: Constructor<T>, lifecycle?: Lifecycle): this;
-    /**
-     * 通过令牌解析依赖项。
-     *
-     * @template T - 依赖项类型
-     * @param token - 标识依赖项的令牌
-     * @returns 已解析的依赖项
-     * @throws Error 如果依赖项未注册
-     */
-    resolve<T>(token: Token<T>): T;
-    /**
-     * 检查依赖项是否已注册。
-     *
-     * @param token - 要检查的令牌
-     * @returns 如果依赖项已注册则返回 true
-     */
-    has(token: Token): boolean;
-    /**
-     * 移除依赖项注册。
-     *
-     * @param token - 要移除的令牌
-     * @returns 如果注册已被移除则返回 true
-     */
-    unregister(token: Token): boolean;
-    /**
-     * 清除所有注册。
-     */
-    clear(): void;
-    /**
-     * 创建子容器。
-     * 子容器从父容器继承注册。
-     *
-     * @returns 新的子容器
-     */
-    createChild(): Container;
-    /**
-     * 获取类的注入元数据。
-     */
-    private getInjectMetadata;
-}
-/**
- * 为了方便而提供的全局容器实例。
- */
-declare const globalContainer: Container;
-/**
- * 将类标记为可注入。
- * 自动依赖解析所必需。
- *
- * @example
- * ```typescript
- * @Injectable()
- * class UserService {
- *   constructor(private userRepo: UserRepository) {}
- * }
- * ```
- *
- * @returns 类装饰器
- */
-declare function Injectable(): ClassDecorator;
-/**
- * 标记构造函数参数以进行注入。
- *
- * @example
- * ```typescript
- * @Injectable()
- * class UserService {
- *   constructor(@Inject('logger') private logger: Logger) {}
- * }
- * ```
- *
- * @param token - 要注入的令牌
- * @returns 参数装饰器
- */
-declare function Inject(token: Token): ParameterDecorator;
-/**
- * 将类标记为单例。
- * 结合 @Injectable 和单例生命周期。
- *
- * @example
- * ```typescript
- * @Singleton()
- * class ConfigService {
- *   // 只会存在一个实例
- * }
- * ```
- *
- * @returns 类装饰器
- */
-declare function Singleton(): ClassDecorator;
-
 /**
  * @fileoverview 方法和类装饰器
  * @module melange/core/decorators
@@ -715,4 +518,4 @@ declare function toDisposable(dispose: () => void): IDisposable;
  */
 declare function combineDisposables(...disposables: IDisposable[]): IDisposable;
 
-export { Bind, Container, Debounce, Deprecated, Disposable, DisposableStore, EventEmitter, type EventMap, type Factory, Frozen, type IDisposable, Inject, Injectable, Lifecycle, Log, Memoize, Retry, Sealed, Singleton, Throttle, Timeout, type Token, Validate, combineDisposables, globalContainer, toDisposable };
+export { Bind, Debounce, Deprecated, Disposable, DisposableStore, EventEmitter, type EventMap, Frozen, type IDisposable, Log, Memoize, Retry, Sealed, Throttle, Timeout, Validate, combineDisposables, toDisposable };