@djodjonx/wiredi 0.0.2

package/dist/index.mjs

@@ -0,0 +1,915 @@
+import { Lifetime } from "awilix";
+
+//#region src/Provider/types.ts
+/**
+* Dependency lifecycle options
+* Independent of the underlying container implementation
+*/
+let ProviderLifecycle = /* @__PURE__ */ function(ProviderLifecycle) {
+	/** Single shared instance throughout the application (default) */
+	ProviderLifecycle["Singleton"] = "singleton";
+	/** New instance created on each resolution */
+	ProviderLifecycle["Transient"] = "transient";
+	/** One instance per scope/child container */
+	ProviderLifecycle["Scoped"] = "scoped";
+	return ProviderLifecycle;
+}({});
+
+//#endregion
+//#region src/Provider/ProviderManager.ts
+/**
+* Currently configured global provider
+* @internal
+*/
+let currentProvider = null;
+/**
+* Configures the DI container provider to use globally
+*
+* Must be called ONCE at the application entry point,
+* before any calls to `useBuilder`.
+*
+* @param provider - The provider instance to use
+* @throws Error if a provider is already configured
+*
+* @example
+* ```typescript
+* // main.ts - Application entry point
+* import 'reflect-metadata'
+* import { container, Lifecycle } from 'tsyringe'
+* import { useContainerProvider, TsyringeProvider } from '@djodjonx/wiredi'
+*
+* useContainerProvider(new TsyringeProvider({ container, Lifecycle }))
+*
+* // Now useBuilder can be used anywhere
+* ```
+*/
+function useContainerProvider(provider) {
+	if (currentProvider !== null) throw new Error(`[WireDI] Provider already configured (${currentProvider.name}). useContainerProvider() should only be called once at app entry point. Use resetContainerProvider() first if you need to reconfigure.`);
+	currentProvider = provider;
+}
+/**
+* Retrieves the configured container provider
+*
+* @returns The configured provider instance
+* @throws Error if no provider is configured
+*
+* @example
+* ```typescript
+* const provider = getContainerProvider()
+* const service = provider.resolve(MyService)
+* ```
+*/
+function getContainerProvider() {
+	if (currentProvider === null) throw new Error("[WireDI] No container provider configured. Call useContainerProvider(provider) at your app entry point before using useBuilder. Example: useContainerProvider(new TsyringeProvider({ container, Lifecycle }))");
+	return currentProvider;
+}
+/**
+* Checks if a provider is currently configured
+*
+* @returns `true` if a provider is configured, `false` otherwise
+*
+* @example
+* ```typescript
+* if (!hasContainerProvider()) {
+*     useContainerProvider(new TsyringeProvider({ container, Lifecycle }))
+* }
+* ```
+*/
+function hasContainerProvider() {
+	return currentProvider !== null;
+}
+/**
+* Resets the global provider (primarily for testing)
+*
+* ⚠️ WARNING: Do not use in production, only for testing purposes
+*
+* @example
+* ```typescript
+* // In a test file
+* beforeEach(() => {
+*     resetContainerProvider()
+*     useContainerProvider(new TsyringeProvider({ container, Lifecycle }))
+* })
+* ```
+*/
+function resetContainerProvider() {
+	if (currentProvider !== null) try {
+		currentProvider.dispose();
+	} catch {}
+	currentProvider = null;
+}
+
+//#endregion
+//#region src/Provider/adapters/TsyringeProvider.ts
+/**
+* tsyringe adapter implementing the ContainerProvider interface
+*
+* Provides integration between WireDI and tsyringe,
+* allowing you to use tsyringe as your DI container while benefiting
+* from WireDI's configuration and validation features.
+*/
+var TsyringeProvider = class TsyringeProvider {
+	/** @inheritdoc */
+	name = "tsyringe";
+	/** The tsyringe container instance */
+	container;
+	/** The tsyringe Lifecycle enum reference */
+	Lifecycle;
+	/**
+	* Creates a new TsyringeProvider instance
+	*
+	* @param dependencies - tsyringe dependencies (container and Lifecycle)
+	* @param options - Configuration options
+	*
+	* @example
+	* ```typescript
+	* import { container, Lifecycle } from 'tsyringe'
+	*
+	* const provider = new TsyringeProvider(
+	*     { container, Lifecycle },
+	*     { useChildContainer: true }
+	* )
+	* ```
+	*/
+	constructor(dependencies, options = {}) {
+		this.Lifecycle = dependencies.Lifecycle;
+		this.container = options.useChildContainer ? dependencies.container.createChildContainer() : dependencies.container;
+	}
+	/** @inheritdoc */
+	registerValue(token, value) {
+		this.container.register(token, { useValue: value });
+	}
+	/** @inheritdoc */
+	registerFactory(token, factory) {
+		this.container.register(token, { useFactory: () => factory(this) });
+	}
+	/** @inheritdoc */
+	registerClass(token, implementation, lifecycle = ProviderLifecycle.Singleton) {
+		const tsyringeLifecycle = this.mapLifecycle(lifecycle);
+		if (this.isConstructor(token)) this.container.register(token, { useClass: implementation ?? token }, { lifecycle: tsyringeLifecycle });
+		else {
+			if (!implementation) throw new Error(`[TsyringeProvider] Implementation required when registering symbol token: ${String(token)}`);
+			this.container.register(token, { useClass: implementation }, { lifecycle: tsyringeLifecycle });
+		}
+	}
+	/** @inheritdoc */
+	isRegistered(token) {
+		return this.container.isRegistered(token);
+	}
+	/** @inheritdoc */
+	resolve(token) {
+		return this.container.resolve(token);
+	}
+	/** @inheritdoc */
+	createScope() {
+		return new TsyringeProvider({
+			container: this.container.createChildContainer(),
+			Lifecycle: this.Lifecycle
+		});
+	}
+	/** @inheritdoc */
+	dispose() {
+		try {
+			this.container.clearInstances();
+		} catch {}
+	}
+	/**
+	* Returns the underlying tsyringe DependencyContainer
+	* @returns The tsyringe container instance
+	*/
+	getUnderlyingContainer() {
+		return this.container;
+	}
+	/**
+	* Maps WireDI lifecycle to tsyringe Lifecycle
+	* @internal
+	*/
+	mapLifecycle(lifecycle) {
+		switch (lifecycle) {
+			case ProviderLifecycle.Singleton: return this.Lifecycle.Singleton;
+			case ProviderLifecycle.Transient: return this.Lifecycle.Transient;
+			case ProviderLifecycle.Scoped: return this.Lifecycle.ContainerScoped;
+			default: return this.Lifecycle.Singleton;
+		}
+	}
+	/**
+	* Type guard to check if a token is a class constructor
+	* @internal
+	*/
+	isConstructor(token) {
+		return typeof token === "function" && !!token.prototype && token.prototype.constructor === token;
+	}
+};
+
+//#endregion
+//#region src/Provider/adapters/AwilixProvider.ts
+/**
+* Awilix adapter implementing the ContainerProvider interface
+*
+* Provides integration between WireDI and Awilix,
+* allowing you to use Awilix as your DI container while benefiting
+* from WireDI's configuration and validation features.
+*/
+var AwilixProvider = class AwilixProvider {
+	/** @inheritdoc */
+	name = "awilix";
+	/** The Awilix container instance */
+	container;
+	/** Maps tokens to Awilix string-based registration names */
+	tokenToName = /* @__PURE__ */ new Map();
+	/** Counter for generating unique token names */
+	nameCounter = 0;
+	/** Lazily loaded awilix module */
+	awilix = null;
+	/**
+	* Creates a new AwilixProvider instance
+	*
+	* @param options - Configuration options
+	*
+	* @remarks
+	* When using the constructor directly, you must call `init()` before use,
+	* or use `createSync()` for synchronous initialization.
+	*/
+	constructor(options = {}) {
+		this.options = options;
+		this.container = null;
+	}
+	/**
+	* Lazily initializes the container (async)
+	* @internal
+	*/
+	async ensureInitialized() {
+		if (this.container) return;
+		this.awilix = await import("awilix");
+		this.container = this.options.container ?? this.awilix.createContainer({ injectionMode: this.options.injectionMode === "CLASSIC" ? this.awilix.InjectionMode.CLASSIC : this.awilix.InjectionMode.PROXY });
+	}
+	/**
+	* Throws if container is not initialized
+	* @internal
+	*/
+	ensureInitializedSync() {
+		if (!this.container) throw new Error("[AwilixProvider] Container not initialized. Call await provider.init() first, or pass a pre-created container in options.");
+	}
+	/**
+	* Initializes the provider asynchronously
+	*
+	* @remarks
+	* Required before using the provider if not using `createSync()`.
+	*
+	* @example
+	* ```typescript
+	* const provider = new AwilixProvider({ injectionMode: 'PROXY' })
+	* await provider.init()
+	* useContainerProvider(provider)
+	* ```
+	*/
+	async init() {
+		await this.ensureInitialized();
+	}
+	/**
+	* Creates a pre-initialized provider synchronously
+	*
+	* @param awilix - The awilix module import
+	* @param options - Configuration options
+	* @returns Fully initialized AwilixProvider instance
+	*
+	* @remarks
+	* This is the recommended way to create an AwilixProvider as it
+	* avoids async initialization and ensures the provider is ready immediately.
+	*
+	* @example
+	* ```typescript
+	* import * as awilix from 'awilix'
+	*
+	* const provider = AwilixProvider.createSync(awilix, {
+	*     injectionMode: 'CLASSIC'
+	* })
+	* ```
+	*/
+	static createSync(awilix, options = {}) {
+		const provider = new AwilixProvider(options);
+		provider.awilix = awilix;
+		provider.container = options.container ?? awilix.createContainer({ injectionMode: options.injectionMode === "CLASSIC" ? awilix.InjectionMode.CLASSIC : awilix.InjectionMode.PROXY });
+		return provider;
+	}
+	/**
+	* Gets or creates a unique string name for a token
+	* Awilix uses string-based registration, so we map symbols/classes to strings
+	* @internal
+	*/
+	getTokenName(token) {
+		if (!this.tokenToName.has(token)) {
+			const name = typeof token === "symbol" ? token.description ?? `token_${this.nameCounter++}` : token.name;
+			this.tokenToName.set(token, name);
+		}
+		return this.tokenToName.get(token);
+	}
+	/**
+	* Maps WireDI lifecycle to Awilix Lifetime
+	* @internal
+	*/
+	mapLifecycle(lifecycle) {
+		this.ensureInitializedSync();
+		switch (lifecycle) {
+			case ProviderLifecycle.Transient: return Lifetime.TRANSIENT;
+			case ProviderLifecycle.Scoped: return Lifetime.SCOPED;
+			case ProviderLifecycle.Singleton:
+			default: return Lifetime.SINGLETON;
+		}
+	}
+	/** @inheritdoc */
+	registerValue(token, value) {
+		this.ensureInitializedSync();
+		const { asValue } = this.awilix;
+		const name = this.getTokenName(token);
+		this.container.register({ [name]: asValue(value) });
+	}
+	/** @inheritdoc */
+	registerFactory(token, factory) {
+		this.ensureInitializedSync();
+		const { asFunction } = this.awilix;
+		const name = this.getTokenName(token);
+		this.container.register({ [name]: asFunction(() => factory(this)).singleton() });
+	}
+	/** @inheritdoc */
+	registerClass(token, impl, lifecycle) {
+		this.ensureInitializedSync();
+		const { asClass } = this.awilix;
+		const name = this.getTokenName(token);
+		const ClassToRegister = impl ?? token;
+		const lifetime = this.mapLifecycle(lifecycle);
+		this.container.register({ [name]: asClass(ClassToRegister).setLifetime(lifetime) });
+	}
+	/** @inheritdoc */
+	isRegistered(token) {
+		this.ensureInitializedSync();
+		const name = this.getTokenName(token);
+		return this.container.hasRegistration(name);
+	}
+	/** @inheritdoc */
+	resolve(token) {
+		this.ensureInitializedSync();
+		const name = this.getTokenName(token);
+		return this.container.resolve(name);
+	}
+	/** @inheritdoc */
+	createScope() {
+		this.ensureInitializedSync();
+		const scopedContainer = this.container.createScope();
+		const scopedProvider = AwilixProvider.createSync(this.awilix, { container: scopedContainer });
+		this.tokenToName.forEach((name, token) => {
+			scopedProvider.tokenToName.set(token, name);
+		});
+		return scopedProvider;
+	}
+	/** @inheritdoc */
+	dispose() {
+		if (this.container) this.container.dispose();
+	}
+	/**
+	* Returns the underlying Awilix container instance
+	* @returns The AwilixContainer instance
+	*/
+	getUnderlyingContainer() {
+		this.ensureInitializedSync();
+		return this.container;
+	}
+};
+
+//#endregion
+//#region src/Provider/adapters/InversifyProvider.ts
+/**
+* InversifyJS adapter implementing the ContainerProvider interface
+*
+* Provides integration between WireDI and InversifyJS,
+* allowing you to use InversifyJS as your DI container while benefiting
+* from WireDI's configuration and validation features.
+*/
+var InversifyProvider = class InversifyProvider {
+	/** @inheritdoc */
+	name = "inversify";
+	/** The InversifyJS container instance */
+	container;
+	/** Default scope for bindings */
+	defaultScope;
+	/** Lazily loaded inversify module */
+	inversify = null;
+	/**
+	* Creates a new InversifyProvider instance
+	*
+	* @param options - Configuration options
+	*
+	* @remarks
+	* When using the constructor directly, you must call `init()` before use,
+	* or use `createSync()` for synchronous initialization.
+	*/
+	constructor(options = {}) {
+		this.options = options;
+		this.defaultScope = options.defaultScope ?? "Singleton";
+		this.container = null;
+	}
+	/**
+	* Lazily initializes the container (async)
+	* @internal
+	*/
+	async ensureInitialized() {
+		if (this.container) return;
+		this.inversify = await import("inversify");
+		this.container = this.options.container ?? new this.inversify.Container();
+	}
+	/**
+	* Throws if container is not initialized
+	* @internal
+	*/
+	ensureInitializedSync() {
+		if (!this.container) throw new Error("[InversifyProvider] Container not initialized. Call await provider.init() first, or pass a pre-created container in options.");
+	}
+	/**
+	* Initializes the provider asynchronously
+	*
+	* @remarks
+	* Required before using the provider if not using `createSync()`.
+	*
+	* @example
+	* ```typescript
+	* const provider = new InversifyProvider()
+	* await provider.init()
+	* useContainerProvider(provider)
+	* ```
+	*/
+	async init() {
+		await this.ensureInitialized();
+	}
+	/**
+	* Creates a pre-initialized provider synchronously
+	*
+	* @param inversify - The inversify module import
+	* @param options - Configuration options
+	* @returns Fully initialized InversifyProvider instance
+	*
+	* @remarks
+	* This is the recommended way to create an InversifyProvider as it
+	* avoids async initialization and ensures the provider is ready immediately.
+	*
+	* @example
+	* ```typescript
+	* import * as inversify from 'inversify'
+	*
+	* const provider = InversifyProvider.createSync(inversify, {
+	*     defaultScope: 'Transient'
+	* })
+	* ```
+	*/
+	static createSync(inversify, options = {}) {
+		const provider = new InversifyProvider(options);
+		provider.inversify = inversify;
+		provider.container = options.container ?? new inversify.Container();
+		return provider;
+	}
+	/**
+	* Maps WireDI lifecycle to InversifyJS binding scope
+	* @internal
+	*/
+	mapLifecycle(lifecycle) {
+		switch (lifecycle) {
+			case ProviderLifecycle.Transient: return "Transient";
+			case ProviderLifecycle.Scoped: return "Request";
+			case ProviderLifecycle.Singleton:
+			default: return "Singleton";
+		}
+	}
+	/**
+	* Applies the scope to an InversifyJS binding
+	* @internal
+	*/
+	applyScope(binding, scope) {
+		switch (scope) {
+			case "Singleton":
+				binding.inSingletonScope();
+				break;
+			case "Transient":
+				binding.inTransientScope();
+				break;
+			case "Request":
+				binding.inRequestScope();
+				break;
+		}
+	}
+	/** @inheritdoc */
+	registerValue(token, value) {
+		this.ensureInitializedSync();
+		if (this.container.isBound(token)) this.container.unbind(token);
+		this.container.bind(token).toConstantValue(value);
+	}
+	/** @inheritdoc */
+	registerFactory(token, factory) {
+		this.ensureInitializedSync();
+		if (this.container.isBound(token)) this.container.unbind(token);
+		this.container.bind(token).toDynamicValue(() => factory(this));
+	}
+	/** @inheritdoc */
+	registerClass(token, impl, lifecycle) {
+		this.ensureInitializedSync();
+		const ClassToRegister = impl ?? token;
+		const scope = this.mapLifecycle(lifecycle);
+		if (this.container.isBound(token)) this.container.unbind(token);
+		const binding = this.container.bind(token).to(ClassToRegister);
+		this.applyScope(binding, scope);
+	}
+	/** @inheritdoc */
+	isRegistered(token) {
+		this.ensureInitializedSync();
+		return this.container.isBound(token);
+	}
+	/** @inheritdoc */
+	resolve(token) {
+		this.ensureInitializedSync();
+		return this.container.get(token);
+	}
+	/** @inheritdoc */
+	createScope() {
+		this.ensureInitializedSync();
+		const childContainer = new this.inversify.Container();
+		return InversifyProvider.createSync(this.inversify, {
+			container: childContainer,
+			defaultScope: this.defaultScope
+		});
+	}
+	/** @inheritdoc */
+	dispose() {
+		if (this.container) this.container.unbindAll();
+	}
+	/**
+	* Returns the underlying InversifyJS Container instance
+	* @returns The InversifyJS Container
+	*/
+	getUnderlyingContainer() {
+		this.ensureInitializedSync();
+		return this.container;
+	}
+};
+
+//#endregion
+//#region src/EventDispatcher/Provider/MutableEventDispatcherProvider.ts
+/**
+* Default EventDispatcherProvider implementation
+*
+* This provider stores listeners in memory and resolves them through the DI container
+* when dispatching events. Each listener must implement an `onEvent(event)` method.
+*
+* @example Basic usage
+* ```typescript
+* import {
+*     MutableEventDispatcherProvider,
+*     useEventDispatcherProvider,
+*     getContainerProvider
+* } from '@djodjonx/wiredi'
+*
+* const eventProvider = new MutableEventDispatcherProvider({
+*     containerProvider: getContainerProvider()
+* })
+* useEventDispatcherProvider(eventProvider)
+* ```
+*
+* @example Dispatching events
+* ```typescript
+* const dispatcher = getEventDispatcherProvider()
+* dispatcher.dispatch(new UserCreatedEvent(user))
+* ```
+*/
+var MutableEventDispatcherProvider = class {
+	/** @inheritdoc */
+	name = "mutable-event-dispatcher";
+	/** Map of event names to their registered listener tokens */
+	listeners = /* @__PURE__ */ new Map();
+	/** DI container provider for resolving listener instances */
+	containerProvider;
+	/**
+	* Creates a new MutableEventDispatcherProvider instance
+	*
+	* @param options - Configuration options including the container provider
+	*/
+	constructor(options) {
+		this.containerProvider = options.containerProvider;
+	}
+	/**
+	* Extracts the event name from an event token (class constructor)
+	* @internal
+	*/
+	getEventName(eventToken) {
+		return eventToken.name;
+	}
+	/**
+	* Extracts the event name from an event instance
+	* @internal
+	*/
+	getEventNameFromInstance(event) {
+		return event.constructor.name;
+	}
+	/** @inheritdoc */
+	register(eventToken, listenerToken) {
+		const eventName = this.getEventName(eventToken);
+		if (!this.listeners.has(eventName)) this.listeners.set(eventName, []);
+		this.listeners.get(eventName).push(listenerToken);
+	}
+	/** @inheritdoc */
+	dispatch(event) {
+		const eventName = this.getEventNameFromInstance(event);
+		const listenerTokens = this.listeners.get(eventName) ?? [];
+		for (const listenerToken of listenerTokens) try {
+			this.containerProvider.resolve(listenerToken).onEvent(event);
+		} catch (error) {
+			console.error(`[MutableEventDispatcherProvider] Error dispatching event "${eventName}":`, error.stack || error.message);
+			throw error;
+		}
+	}
+	/** @inheritdoc */
+	hasListeners(eventToken) {
+		const eventName = this.getEventName(eventToken);
+		const listeners = this.listeners.get(eventName);
+		return listeners !== void 0 && listeners.length > 0;
+	}
+	/** @inheritdoc */
+	clearListeners(eventToken) {
+		const eventName = this.getEventName(eventToken);
+		this.listeners.delete(eventName);
+	}
+	/** @inheritdoc */
+	clearAllListeners() {
+		this.listeners.clear();
+	}
+	/**
+	* Returns the internal listeners map
+	* @returns Map of event names to listener tokens
+	*/
+	getUnderlyingDispatcher() {
+		return this.listeners;
+	}
+};
+
+//#endregion
+//#region src/EventDispatcher/Provider/index.ts
+/**
+* Currently configured global event dispatcher provider
+* @internal
+*/
+let globalEventDispatcherProvider = null;
+/**
+* Sets the global EventDispatcherProvider instance
+*
+* Call this once at application startup after setting up the container provider.
+* The event dispatcher uses the container provider to resolve listener instances.
+*
+* @param provider - The EventDispatcherProvider implementation to use
+* @throws Error if a provider is already registered
+*
+* @example
+* ```typescript
+* import {
+*     useContainerProvider,
+*     TsyringeProvider,
+*     useEventDispatcherProvider,
+*     MutableEventDispatcherProvider,
+*     getContainerProvider
+* } from '@djodjonx/wiredi'
+*
+* // 1. Setup DI container first
+* useContainerProvider(new TsyringeProvider({ container, Lifecycle }))
+*
+* // 2. Setup event dispatcher (optional)
+* useEventDispatcherProvider(new MutableEventDispatcherProvider({
+*     containerProvider: getContainerProvider()
+* }))
+* ```
+*/
+function useEventDispatcherProvider(provider) {
+	if (globalEventDispatcherProvider !== null) throw new Error(`[EventDispatcher] Provider already registered: "${globalEventDispatcherProvider.name}". Cannot register "${provider.name}". Call resetEventDispatcherProvider() first if you need to change it.`);
+	globalEventDispatcherProvider = provider;
+}
+/**
+* Retrieves the currently registered EventDispatcherProvider
+*
+* @returns The registered EventDispatcherProvider instance
+* @throws Error if no provider has been registered
+*
+* @example
+* ```typescript
+* const eventDispatcher = getEventDispatcherProvider()
+* eventDispatcher.dispatch(new UserCreatedEvent(user))
+* ```
+*/
+function getEventDispatcherProvider() {
+	if (globalEventDispatcherProvider === null) throw new Error("[EventDispatcher] No provider registered. Call useEventDispatcherProvider() at application startup.");
+	return globalEventDispatcherProvider;
+}
+/**
+* Checks if an EventDispatcherProvider has been registered
+*
+* @returns `true` if a provider is registered, `false` otherwise
+*
+* @example
+* ```typescript
+* if (hasEventDispatcherProvider()) {
+*     getEventDispatcherProvider().dispatch(event)
+* }
+* ```
+*/
+function hasEventDispatcherProvider() {
+	return globalEventDispatcherProvider !== null;
+}
+/**
+* Resets the global EventDispatcherProvider
+*
+* Clears all registered listeners and removes the provider.
+* Useful for testing or reconfiguration scenarios.
+*
+* ⚠️ WARNING: This should rarely be used in production code.
+*
+* @example
+* ```typescript
+* // In a test file
+* afterEach(() => {
+*     resetEventDispatcherProvider()
+* })
+* ```
+*/
+function resetEventDispatcherProvider() {
+	if (globalEventDispatcherProvider !== null) globalEventDispatcherProvider.clearAllListeners();
+	globalEventDispatcherProvider = null;
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Type guard to check if a token is a constructor (class).
+* @param token The token to check.
+* @returns True if the token is a constructor, false otherwise.
+*/
+function isConstructor(token) {
+	return typeof token === "function" && !!token.prototype && token.prototype.constructor === token;
+}
+function registerConfig(provider, injections, context) {
+	injections.forEach((entry) => {
+		if (provider.isRegistered(entry.token)) return;
+		if ("value" in entry) provider.registerValue(entry.token, entry.value(context));
+		else if ("factory" in entry) provider.registerFactory(entry.token, () => entry.factory(provider));
+		else if (isConstructor(entry.token)) {
+			const lifecycle = entry.lifecycle ?? ProviderLifecycle.Singleton;
+			provider.registerClass(entry.token, entry.token, lifecycle);
+		} else {
+			if (!("provider" in entry)) throw new Error(`Provider required when registering token Symbol: ${String(entry.token)}`);
+			const lifecycle = entry.lifecycle ?? ProviderLifecycle.Singleton;
+			provider.registerClass(entry.token, entry.provider, lifecycle);
+		}
+	});
+}
+function registerEvent(_provider, listeners) {
+	if (!listeners.length) return;
+	if (!hasEventDispatcherProvider()) return;
+	const eventDispatcher = getEventDispatcherProvider();
+	listeners.forEach((configEntry) => {
+		eventDispatcher.register(configEntry.event, configEntry.listener);
+	});
+}
+/**
+* Helper to define a partial configuration (injections/listeners).
+*
+* Partials are designed to be flat collections of dependencies. They do not support
+* inheritance (`extends`) or overriding to prevent complex dependency graphs.
+* All conflict resolution must happen in the main `defineBuilderConfig`.
+*
+* @template C The type of the context object (optional).
+* @template I The specific type of the injections array (inferred).
+* @param config The partial builder configuration object.
+* @returns The configuration object typed as TypedPartialConfig.
+*/
+function definePartialConfig(config) {
+	return config;
+}
+/**
+* A helper function to define a builder configuration with strict type inference and inheritance.
+* Use this instead of manually casting with `satisfies BuilderConfig` or `as const`
+* to ensure that `useBuilder` can correctly infer the available tokens.
+*
+* This function now supports `extends` to inherit from `definePartialConfig` definitions.
+* Token collisions are strictly forbidden - each token must be unique across all partials
+* and the main configuration to prevent accidental redefinition.
+*
+* @template C The type of the context object (optional).
+* @template Partials The tuple of partial configs to extend.
+* @template LocalInjections The specific type of the local injections array (inferred).
+* @param config The builder configuration object.
+* @returns The configuration object typed as TypedBuilderConfig to simplify IDE display.
+*
+* @example
+* ```typescript
+* import { Lifecycle } from 'tsyringe';
+*
+* class MyService {}
+* class MyProvider {}
+* class MyEvent {}
+* class MyEventListener {
+*   onEvent(event: MyEvent) {
+*     console.log('Event received:', event);
+*   }
+* }
+*
+* const MY_TOKEN = Symbol('MY_TOKEN');
+* const MY_VALUE_TOKEN = Symbol('MY_VALUE_TOKEN');
+* const MY_FACTORY_TOKEN = Symbol('MY_FACTORY_TOKEN');
+*
+* // --- Partial Configuration ---
+* const myPartial = definePartialConfig({
+*   injections: [
+*     { token: MyService } // Provides MyService
+*   ],
+*   listeners: [
+*     { event: MyEvent, listener: MyEventListener }
+*   ]
+* });
+*
+* // --- Main Builder Configuration ---
+* const myBuilderConfig = defineBuilderConfig({
+*   builderId: 'my.unique.builder',
+*   extends: [myPartial],
+*   injections: [
+*     // ❌ ERROR: Token collision - MyService is already defined in myPartial
+*     // { token: MyService },
+*
+*     // ✅ OK: New tokens not in partials
+*     { token: MY_TOKEN, provider: MyProvider },
+*     { token: MY_TOKEN, provider: MyProvider, lifecycle: Lifecycle.Transient },
+*
+*     // 3. Value Injection (can use optional context)
+*     { token: MY_VALUE_TOKEN, value: (context) => context?.someConfig ?? 'defaultValue' },
+*
+*     // 4. Factory Injection
+*     { token: MY_FACTORY_TOKEN, factory: (container) => new MyService() },
+*   ],
+*   listeners: [
+*     // ❌ ERROR: Duplicate listener (Event + Listener pair already in myPartial)
+*     // { event: MyEvent, listener: MyEventListener },
+*
+*     // ✅ OK: New listener not in partials
+*     { event: OtherEvent, listener: OtherEventListener },
+*   ],
+* });
+*
+* // Usage:
+* // const { resolve } = useBuilder(myBuilderConfig, { someConfig: 'custom' });
+* // const service = resolve(MyService);
+* // const value = resolve(MY_VALUE_TOKEN);
+* ```
+*/
+function defineBuilderConfig(config) {
+	const mergedInjections = [...config.injections, ...(config.extends || []).flatMap((p) => p.injections || [])];
+	const mergedListeners = [...(config.extends || []).flatMap((p) => p.listeners || []), ...config.listeners];
+	return {
+		...config,
+		injections: mergedInjections,
+		listeners: mergedListeners
+	};
+}
+/**
+* A composable function for setting up and interacting with a dependency injection container
+* based on a `BuilderConfig`. It ensures that dependencies are registered only once per builderId
+* and provides a type-safe `resolve` method.
+*
+* The `resolve` method is strictly type-checked to only allow tokens defined within the `injections`
+* array of the provided `config`.
+*
+* ⚠️ Requires `useContainerProvider()` to be called first at app entry point.
+*
+* @template C The type of the context object that might be passed to value providers.
+* @template Tokens The inferred tuple of allowed tokens from the config.
+* @param config The typed builder configuration object.
+* @param context An optional context object that can be passed to value providers in the injections.
+* @returns An `IUseBuilder` instance with a type-safe `resolve` method.
+*
+* @example
+* ```typescript
+* // main.ts - Entry point
+* import { useContainerProvider, TsyringeProvider } from '@djodjonx/wiredi'
+* useContainerProvider(new TsyringeProvider())
+*
+* // anywhere.ts
+* import { useBuilder } from '@djodjonx/wiredi'
+* const { resolve } = useBuilder(myConfig)
+* const service = resolve(MyService)
+* ```
+*/
+function useBuilder(config, context) {
+	const provider = getContainerProvider();
+	const builderIdToken = Symbol.for(`__builder__${config.builderId}`);
+	if (!provider.isRegistered(builderIdToken)) {
+		registerConfig(provider, config.injections, context);
+		registerEvent(provider, config.listeners);
+		provider.registerValue(builderIdToken, config.builderId);
+	}
+	const resolve = (token) => provider.resolve(token);
+	return { resolve };
+}
+
+//#endregion
+export { AwilixProvider, InversifyProvider, MutableEventDispatcherProvider, ProviderLifecycle, TsyringeProvider, useBuilder as default, defineBuilderConfig, definePartialConfig, getContainerProvider, getEventDispatcherProvider, hasContainerProvider, hasEventDispatcherProvider, resetContainerProvider, resetEventDispatcherProvider, useContainerProvider, useEventDispatcherProvider };
+//# sourceMappingURL=index.mjs.map