@navios/di 0.5.0 → 0.6.0

package/lib/index.mjs

@@ -1,70 +1,332 @@
-import { Injectable, __decoratorStart, __decorateElement, __runInitializers, InjectionToken, globalRegistry, InjectableTokenMeta } from './chunk-44F3LXW5.mjs';
-export { BaseInstanceHolderManager, BoundInjectionToken, Container, DIError, DIErrorCode, DefaultRequestContextHolder, DIErrorCode as ErrorsEnum, FactoryInjectionToken, DIError as FactoryNotFound, DIError as FactoryTokenNotResolved, Injectable, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, DIError as InstanceDestroying, DIError as InstanceNotFound, Registry, ServiceInstantiator, ServiceLocator, ServiceLocatorEventBus, ServiceLocatorInstanceHolderStatus, ServiceLocatorManager, DIError as UnknownError, asyncInject, createRequestContextHolder, defaultInjectors, getInjectableToken, getInjectors, globalRegistry, inject, optional, provideFactoryContext, wrapSyncInit } from './chunk-44F3LXW5.mjs';
+import { A as withoutResolutionContext, B as InjectableType, C as provideFactoryContext, D as getCurrentResolutionContext, E as getInjectors, F as Registry, I as globalRegistry, L as BoundInjectionToken, M as DIErrorCode, N as Injectable, O as resolutionContext, P as InjectableTokenMeta, R as FactoryInjectionToken, S as optional, T as getInjectableToken, V as InjectableScope, _ as InstanceStatus, a as TokenProcessor, b as defaultInjectors, c as Invalidator, d as SingletonStorage, f as ScopedContainer, g as BaseHolderManager, h as createRequestContext, i as ServiceLocator, j as DIError, k as withResolutionContext, l as Instantiator, m as DefaultRequestContext, n as _TestContainer, o as HolderManager, p as RequestStorage, r as _Container, s as LifecycleEventBus, t as TestBindingBuilder, u as InstanceResolver, v as CircularDetector, w as wrapSyncInit, x as inject, y as asyncInject, z as InjectionToken } from "./testing-DCXz8AJD.mjs";
+import { z } from "zod/v4";
 
-// src/decorators/factory.decorator.mts
-function Factory({
-  scope = "Singleton" /* Singleton */,
-  token,
-  registry = globalRegistry
-} = {}) {
-  return (target, context) => {
-    if (context && context.kind !== "class" || target instanceof Function && !context) {
-      throw new Error(
-        "[ServiceLocator] @Factory decorator can only be used on classes."
-      );
-    }
-    let injectableToken = token ?? InjectionToken.create(target);
-    registry.set(injectableToken, scope, target, "Factory" /* Factory */);
-    target[InjectableTokenMeta] = injectableToken;
-    return target;
-  };
+//#region src/decorators/factory.decorator.mts
+function Factory({ scope = InjectableScope.Singleton, token, registry = globalRegistry } = {}) {
+	return (target, context) => {
+		if (context && context.kind !== "class" || target instanceof Function && !context) throw new Error("[ServiceLocator] @Factory decorator can only be used on classes.");
+		let injectableToken = token ?? InjectionToken.create(target);
+		registry.set(injectableToken, scope, target, InjectableType.Factory);
+		target[InjectableTokenMeta] = injectableToken;
+		return target;
+	};
 }
 
-// src/event-emitter.mts
-var _EventEmitter_decorators, _init;
-_EventEmitter_decorators = [Injectable({ scope: "Transient" /* Transient */ })];
+//#endregion
+//#region src/event-emitter.mts
+function applyDecs2203RFactory() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass;
+let _EventEmitter;
+_dec = Injectable({ scope: InjectableScope.Transient });
 var EventEmitter = class {
-  listeners = /* @__PURE__ */ new Map();
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(listener);
-    return () => {
-      this.off(event, listener);
-    };
-  }
-  off(event, listener) {
-    if (!this.listeners.has(event)) {
-      return;
-    }
-    this.listeners.get(event).delete(listener);
-    if (this.listeners.get(event).size === 0) {
-      this.listeners.delete(event);
-    }
-  }
-  once(event, listener) {
-    const off = this.on(event, (...args) => {
-      off();
-      listener(...args);
-    });
-    return off;
-  }
-  async emit(event, ...args) {
-    if (!this.listeners.has(event)) {
-      return;
-    }
-    return Promise.all(
-      Array.from(this.listeners.get(event)).map(
-        (listener) => listener(...args)
-      )
-    );
-  }
+	static {
+		({c: [_EventEmitter, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	listeners = /* @__PURE__ */ new Map();
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+		return () => {
+			this.off(event, listener);
+		};
+	}
+	off(event, listener) {
+		if (!this.listeners.has(event)) return;
+		this.listeners.get(event).delete(listener);
+		if (this.listeners.get(event).size === 0) this.listeners.delete(event);
+	}
+	once(event, listener) {
+		const off = this.on(event, (...args) => {
+			off();
+			listener(...args);
+		});
+		return off;
+	}
+	async emit(event, ...args) {
+		if (!this.listeners.has(event)) return;
+		return Promise.all(Array.from(this.listeners.get(event)).map((listener) => listener(...args)));
+	}
+	static {
+		_initClass();
+	}
 };
-_init = __decoratorStart(null);
-EventEmitter = __decorateElement(_init, 0, "EventEmitter", _EventEmitter_decorators, EventEmitter);
-__runInitializers(_init, 1, EventEmitter);
 
-export { EventEmitter, Factory };
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { BaseHolderManager, BoundInjectionToken, CircularDetector, _Container as Container, DIError, DIErrorCode, DefaultRequestContext, _EventEmitter as EventEmitter, Factory, FactoryInjectionToken, HolderManager, Injectable, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, InstanceResolver, InstanceStatus, Instantiator, Invalidator, LifecycleEventBus, Registry, RequestStorage, ScopedContainer, ServiceLocator, SingletonStorage, TestBindingBuilder, _TestContainer as TestContainer, TokenProcessor, asyncInject, createRequestContext, defaultInjectors, getCurrentResolutionContext, getInjectableToken, getInjectors, globalRegistry, inject, optional, provideFactoryContext, resolutionContext, withResolutionContext, withoutResolutionContext, wrapSyncInit };
 //# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/decorators/factory.decorator.mts","../src/event-emitter.mts"],"names":[],"mappings":";;;;AA8CO,SAAS,OAAA,CAAQ;AAAA,EACtB,KAAA,GAAA,WAAA;AAAA,EACA,KAAA;AAAA,EACA,QAAA,GAAW;AACb,CAAA,GAAoB,EAAC,EAAG;AACtB,EAAA,OAAO,CAKL,QACA,OAAA,KACM;AACN,IAAA,IACG,WAAW,OAAA,CAAQ,IAAA,KAAS,WAC5B,MAAA,YAAkB,QAAA,IAAY,CAAC,OAAA,EAChC;AACA,MAAA,MAAM,IAAI,KAAA;AAAA,QACR;AAAA,OACF;AAAA,IACF;AAEA,IAAA,IAAI,eAAA,GACF,KAAA,IAAS,cAAA,CAAe,MAAA,CAAO,MAAM,CAAA;AAEvC,IAAA,QAAA,CAAS,GAAA,CAAI,eAAA,EAAiB,KAAA,EAAO,MAAA,EAAA,SAAA,eAA8B;AAGnE,IAAA,MAAA,CAAO,mBAAmB,CAAA,GAAI,eAAA;AAE9B,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;AC9EA,IAAA,wBAAA,EAAA,KAAA;AA0CA,wBAAA,GAAA,CAAC,UAAA,CAAW,EAAE,KAAA,EAAA,WAAA,kBAAkC,CAAA,CAAA;AACzC,IAAM,eAAN,MAEP;AAAA,EACU,SAAA,uBAAyD,GAAA,EAAI;AAAA,EAErE,EAAA,CACE,OACA,QAAA,EACA;AACA,IAAA,IAAI,CAAC,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,EAAG;AAC9B,MAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAA,kBAAO,IAAI,KAAK,CAAA;AAAA,IACrC;AAEA,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,CAAG,IAAI,QAAQ,CAAA;AAEvC,IAAA,OAAO,MAAM;AACX,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,QAAQ,CAAA;AAAA,IAC1B,CAAA;AAAA,EACF;AAAA,EAEA,GAAA,CACE,OACA,QAAA,EACA;AACA,IAAA,IAAI,CAAC,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,EAAG;AAC9B,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,CAAG,OAAO,QAAQ,CAAA;AAC1C,IAAA,IAAI,KAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,CAAG,SAAS,CAAA,EAAG;AACzC,MAAA,IAAA,CAAK,SAAA,CAAU,OAAO,KAAK,CAAA;AAAA,IAC7B;AAAA,EACF;AAAA,EAEA,IAAA,CACE,OACA,QAAA,EACA;AACA,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,EAAA,CAAG,KAAA,EAAO,IAAI,IAAA,KAAS;AACtC,MAAA,GAAA,EAAI;AAEJ,MAAA,QAAA,CAAS,GAAG,IAAI,CAAA;AAAA,IAClB,CAAC,CAAA;AAED,IAAA,OAAO,GAAA;AAAA,EACT;AAAA,EAEA,MAAM,IAAA,CACJ,KAAA,EAAA,GACG,IAAA,EACW;AACd,IAAA,IAAI,CAAC,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,EAAG;AAC9B,MAAA;AAAA,IACF;AAEA,IAAA,OAAO,OAAA,CAAQ,GAAA;AAAA,MACb,MAAM,IAAA,CAAK,IAAA,CAAK,UAAU,GAAA,CAAI,KAAK,CAAE,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,QAAA,KAC1C,QAAA,CAAS,GAAG,IAAI;AAAA;AAClB,KACF;AAAA,EACF;AACF;AA7DO,KAAA,GAAA,gBAAA,CAAA,IAAA,CAAA;AAAM,YAAA,GAAN,4CADP,wBAAA,EACa,YAAA,CAAA;AAAN,iBAAA,CAAA,KAAA,EAAA,CAAA,EAAM,YAAA,CAAA","file":"index.mjs","sourcesContent":["import type {\n  ClassTypeWithInstance,\n  InjectionTokenSchemaType,\n} from '../injection-token.mjs'\nimport type { Factorable, FactorableWithArgs } from '../interfaces/index.mjs'\nimport type { Registry } from '../registry.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\nimport { InjectionToken } from '../injection-token.mjs'\nimport { globalRegistry } from '../registry.mjs'\nimport { InjectableTokenMeta } from '../symbols/index.mjs'\n\nexport interface FactoryOptions {\n  scope?: InjectableScope\n  token?: InjectionToken<any, any>\n  registry?: Registry\n}\n\n// #1 Factory without arguments\nexport function Factory<R>(options?: {\n  scope?: InjectableScope\n  registry?: Registry\n}): <T extends ClassTypeWithInstance<Factorable<R>>>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n\n// #2 Factory with typed token\nexport function Factory<R, S>(options: {\n  scope?: InjectableScope\n  token: InjectionToken<R, S>\n  registry?: Registry\n}): R extends undefined // #2.1 Check that token has a type\n  ? never // #2.1.1 Token must have a type\n  : S extends InjectionTokenSchemaType // #2.2 Check that schema is an object or a record\n    ? <T extends ClassTypeWithInstance<FactorableWithArgs<R, S>>>( // #2.2.1 Token have a schema\n        target: T,\n        context?: ClassDecoratorContext,\n      ) => T\n    : S extends undefined // #2.3 For a factory without schema\n      ? <T extends ClassTypeWithInstance<Factorable<R>>>( // #2.3.1 Token without a schema\n          target: T,\n          context?: ClassDecoratorContext,\n        ) => T\n      : never // #2.4 Cannot use a token without a type and schema\n\nexport function Factory({\n  scope = InjectableScope.Singleton,\n  token,\n  registry = globalRegistry,\n}: FactoryOptions = {}) {\n  return <\n    T extends ClassTypeWithInstance<\n      Factorable<any> | FactorableWithArgs<any, any>\n    >,\n  >(\n    target: T,\n    context?: ClassDecoratorContext,\n  ): T => {\n    if (\n      (context && context.kind !== 'class') ||\n      (target instanceof Function && !context)\n    ) {\n      throw new Error(\n        '[ServiceLocator] @Factory decorator can only be used on classes.',\n      )\n    }\n\n    let injectableToken: InjectionToken<any, any> =\n      token ?? InjectionToken.create(target)\n\n    registry.set(injectableToken, scope, target, InjectableType.Factory)\n\n    // @ts-expect-error\n    target[InjectableTokenMeta] = injectableToken\n\n    return target\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\n/* eslint-disable @typescript-eslint/no-empty-object-type */\n/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n\nimport { Injectable, InjectableScope } from './index.mjs'\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport type EventsConfig = {\n  [event: string]: any[]\n}\nexport type EventsNames<Events extends EventsConfig> = Exclude<\n  keyof Events,\n  symbol | number\n>\nexport type EventsArgs<\n  Events extends EventsConfig,\n  Name extends EventsNames<Events>,\n> = Events[Name] extends any[] ? Events[Name] : []\n\nexport type ChannelEmitter<\n  Events extends EventsConfig,\n  Ns extends string,\n  E extends EventsNames<Events>,\n> = {\n  emit<Args extends EventsArgs<Events, E>>(\n    ns: Ns,\n    event: E,\n    ...args: Args\n  ): Promise<any>\n}\n\nexport interface EventEmitterInterface<Events extends EventsConfig> {\n  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ): () => void\n  emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    ...args: Args\n  ): void | Promise<void>\n}\n\n@Injectable({ scope: InjectableScope.Transient })\nexport class EventEmitter<Events extends EventsConfig = {}>\n  implements EventEmitterInterface<Events>\n{\n  private listeners: Map<EventsNames<Events>, Set<Function>> = new Map()\n\n  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ) {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, new Set())\n    }\n\n    this.listeners.get(event)!.add(listener)\n\n    return () => {\n      this.off(event, listener)\n    }\n  }\n\n  off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ) {\n    if (!this.listeners.has(event)) {\n      return\n    }\n\n    this.listeners.get(event)!.delete(listener)\n    if (this.listeners.get(event)!.size === 0) {\n      this.listeners.delete(event)\n    }\n  }\n\n  once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ) {\n    const off = this.on(event, (...args) => {\n      off()\n      // @ts-expect-error - This is a valid call\n      listener(...args)\n    })\n\n    return off\n  }\n\n  async emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    ...args: Args\n  ): Promise<any> {\n    if (!this.listeners.has(event)) {\n      return\n    }\n\n    return Promise.all(\n      Array.from(this.listeners.get(event)!).map((listener) =>\n        listener(...args),\n      ),\n    )\n  }\n}\n"]}
+{"version":3,"file":"index.mjs","names":["InjectableScope","InjectableType","InjectionToken","globalRegistry","InjectableTokenMeta","Factory","scope","Singleton","token","registry","target","context","kind","Function","Error","injectableToken","create","set","Injectable","InjectableScope","scope","Transient","EventEmitter","listeners","Map","on","event","listener","has","set","Set","get","add","off","delete","size","once","args","emit","Promise","all","Array","from","map"],"sources":["../src/decorators/factory.decorator.mts","../src/event-emitter.mts"],"sourcesContent":["import type {\n  ClassTypeWithInstance,\n  InjectionTokenSchemaType,\n} from '../token/injection-token.mjs'\nimport type { Factorable, FactorableWithArgs } from '../interfaces/index.mjs'\nimport type { Registry } from '../token/registry.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\nimport { InjectionToken } from '../token/injection-token.mjs'\nimport { globalRegistry } from '../token/registry.mjs'\nimport { InjectableTokenMeta } from '../symbols/index.mjs'\n\nexport interface FactoryOptions {\n  scope?: InjectableScope\n  token?: InjectionToken<any, any>\n  registry?: Registry\n}\n\n// #1 Factory without arguments\nexport function Factory<R>(options?: {\n  scope?: InjectableScope\n  registry?: Registry\n}): <T extends ClassTypeWithInstance<Factorable<R>>>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n\n// #2 Factory with typed token\nexport function Factory<R, S>(options: {\n  scope?: InjectableScope\n  token: InjectionToken<R, S>\n  registry?: Registry\n}): R extends undefined // #2.1 Check that token has a type\n  ? never // #2.1.1 Token must have a type\n  : S extends InjectionTokenSchemaType // #2.2 Check that schema is an object or a record\n    ? <T extends ClassTypeWithInstance<FactorableWithArgs<R, S>>>( // #2.2.1 Token have a schema\n        target: T,\n        context?: ClassDecoratorContext,\n      ) => T\n    : S extends undefined // #2.3 For a factory without schema\n      ? <T extends ClassTypeWithInstance<Factorable<R>>>( // #2.3.1 Token without a schema\n          target: T,\n          context?: ClassDecoratorContext,\n        ) => T\n      : never // #2.4 Cannot use a token without a type and schema\n\nexport function Factory({\n  scope = InjectableScope.Singleton,\n  token,\n  registry = globalRegistry,\n}: FactoryOptions = {}) {\n  return <\n    T extends ClassTypeWithInstance<\n      Factorable<any> | FactorableWithArgs<any, any>\n    >,\n  >(\n    target: T,\n    context?: ClassDecoratorContext,\n  ): T => {\n    if (\n      (context && context.kind !== 'class') ||\n      (target instanceof Function && !context)\n    ) {\n      throw new Error(\n        '[ServiceLocator] @Factory decorator can only be used on classes.',\n      )\n    }\n\n    let injectableToken: InjectionToken<any, any> =\n      token ?? InjectionToken.create(target)\n\n    registry.set(injectableToken, scope, target, InjectableType.Factory)\n\n    // @ts-expect-error\n    target[InjectableTokenMeta] = injectableToken\n\n    return target\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\n/* eslint-disable @typescript-eslint/no-empty-object-type */\n/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n\nimport { Injectable, InjectableScope } from './index.mjs'\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport type EventsConfig = {\n  [event: string]: any[]\n}\nexport type EventsNames<Events extends EventsConfig> = Exclude<\n  keyof Events,\n  symbol | number\n>\nexport type EventsArgs<\n  Events extends EventsConfig,\n  Name extends EventsNames<Events>,\n> = Events[Name] extends any[] ? Events[Name] : []\n\nexport type ChannelEmitter<\n  Events extends EventsConfig,\n  Ns extends string,\n  E extends EventsNames<Events>,\n> = {\n  emit<Args extends EventsArgs<Events, E>>(\n    ns: Ns,\n    event: E,\n    ...args: Args\n  ): Promise<any>\n}\n\nexport interface EventEmitterInterface<Events extends EventsConfig> {\n  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ): () => void\n  emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    ...args: Args\n  ): void | Promise<void>\n}\n\n@Injectable({ scope: InjectableScope.Transient })\nexport class EventEmitter<Events extends EventsConfig = {}>\n  implements EventEmitterInterface<Events>\n{\n  private listeners: Map<EventsNames<Events>, Set<Function>> = new Map()\n\n  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ) {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, new Set())\n    }\n\n    this.listeners.get(event)!.add(listener)\n\n    return () => {\n      this.off(event, listener)\n    }\n  }\n\n  off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ) {\n    if (!this.listeners.has(event)) {\n      return\n    }\n\n    this.listeners.get(event)!.delete(listener)\n    if (this.listeners.get(event)!.size === 0) {\n      this.listeners.delete(event)\n    }\n  }\n\n  once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    listener: (...args: Args) => void | Promise<void>,\n  ) {\n    const off = this.on(event, (...args) => {\n      off()\n      // @ts-expect-error - This is a valid call\n      listener(...args)\n    })\n\n    return off\n  }\n\n  async emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(\n    event: E,\n    ...args: Args\n  ): Promise<any> {\n    if (!this.listeners.has(event)) {\n      return\n    }\n\n    return Promise.all(\n      Array.from(this.listeners.get(event)!).map((listener) =>\n        listener(...args),\n      ),\n    )\n  }\n}\n"],"mappings":";;;;AA8CA,SAAgBK,QAAQ,EACtBC,QAAQN,gBAAgBO,WACxBC,OACAC,WAAWN,mBACO,EAAE,EAAA;AACpB,SAKEO,QACAC,YAAAA;AAEA,MACE,WAAYA,QAAQC,SAAS,WAC5BF,kBAAkBG,YAAY,CAACF,QAEhC,OAAM,IAAIG,MACR,mEAAA;EAIJ,IAAIC,kBACFP,SAASN,eAAec,OAAON,OAAAA;AAEjCD,WAASQ,IAAIF,iBAAiBT,OAAOI,QAAQT,eAAeI,QAAO;AAGnEK,SAAON,uBAAuBW;AAE9B,SAAOL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OClCVQ,WAAW,EAAEE,OAAOD,gBAAgBE,WAAU,CAAA;AACxC,IAAMC,eAAN,MAAMA;;;;CAGHC,4BAAqD,IAAIC,KAAAA;CAEjEC,GACEC,OACAC,UACA;AACA,MAAI,CAAC,KAAKJ,UAAUK,IAAIF,MAAAA,CACtB,MAAKH,UAAUM,IAAIH,uBAAO,IAAII,KAAAA,CAAAA;AAGhC,OAAKP,UAAUQ,IAAIL,MAAAA,CAAQM,IAAIL,SAAAA;AAE/B,eAAO;AACL,QAAKM,IAAIP,OAAOC,SAAAA;;;CAIpBM,IACEP,OACAC,UACA;AACA,MAAI,CAAC,KAAKJ,UAAUK,IAAIF,MAAAA,CACtB;AAGF,OAAKH,UAAUQ,IAAIL,MAAAA,CAAQQ,OAAOP,SAAAA;AAClC,MAAI,KAAKJ,UAAUQ,IAAIL,MAAAA,CAAQS,SAAS,EACtC,MAAKZ,UAAUW,OAAOR,MAAAA;;CAI1BU,KACEV,OACAC,UACA;EACA,MAAMM,MAAM,KAAKR,GAAGC,QAAQ,GAAGW,SAAAA;AAC7BJ,QAAAA;AAEAN,YAAAA,GAAYU,KAAAA;IACd;AAEA,SAAOJ;;CAGT,MAAMK,KACJZ,OACA,GAAGW,MACW;AACd,MAAI,CAAC,KAAKd,UAAUK,IAAIF,MAAAA,CACtB;AAGF,SAAOa,QAAQC,IACbC,MAAMC,KAAK,KAAKnB,UAAUQ,IAAIL,MAAAA,CAAAA,CAASiB,KAAKhB,aAC1CA,SAAAA,GAAYU,KAAAA,CAAAA,CAAAA"}

package/lib/testing/index.cjs

@@ -0,0 +1,9 @@
+const require_testing = require('../testing-BMGmmxH7.cjs');
+
+exports.TestBindingBuilder = require_testing.TestBindingBuilder;
+Object.defineProperty(exports, 'TestContainer', {
+  enumerable: true,
+  get: function () {
+    return require_testing._TestContainer;
+  }
+});

package/lib/testing/index.d.cts

@@ -0,0 +1,2 @@
+import { n as TestContainer, t as TestBindingBuilder } from "../index-fKPuT65j.cjs";
+export { TestBindingBuilder, TestContainer };

package/lib/testing/index.d.mts

@@ -1,2 +1,2 @@
-export { TestBindingBuilder } from '../_tsup-dts-rollup.mjs';
-export { TestContainer } from '../_tsup-dts-rollup.mjs';
+import { n as TestContainer, t as TestBindingBuilder } from "../index-S_qX2VLI.mjs";
+export { TestBindingBuilder, TestContainer };

package/lib/testing/index.mjs

@@ -1,73 +1,3 @@
-import { Injectable, __decoratorStart, __decorateElement, __runInitializers, Container, globalRegistry, getInjectableToken } from '../chunk-44F3LXW5.mjs';
+import { n as _TestContainer, t as TestBindingBuilder } from "../testing-DCXz8AJD.mjs";
 
-// src/testing/test-container.mts
-var TestBindingBuilder = class {
-  constructor(container, token) {
-    this.container = container;
-    this.token = token;
-  }
-  /**
-   * Binds the token to a specific value.
-   * This is useful for testing with mock values or constants.
-   * @param value The value to bind to the token
-   */
-  toValue(value) {
-    const instanceName = this.container.getServiceLocator().getInstanceIdentifier(this.token);
-    this.container.getServiceLocator().getManager().storeCreatedHolder(
-      instanceName,
-      value,
-      "Class" /* Class */,
-      "Singleton" /* Singleton */
-    );
-    return this.container;
-  }
-  /**
-   * Binds the token to a class constructor.
-   * @param target The class constructor to bind to
-   */
-  toClass(target) {
-    this.container["registry"].set(
-      this.token,
-      "Singleton" /* Singleton */,
-      target,
-      "Class" /* Class */
-    );
-    return this.container;
-  }
-};
-var _TestContainer_decorators, _init, _a;
-_TestContainer_decorators = [Injectable()];
-var _TestContainer = class _TestContainer extends (_a = Container) {
-  constructor(registry = globalRegistry, logger = null, injectors = void 0) {
-    super(registry, logger, injectors);
-  }
-  bind(token) {
-    let realToken = token;
-    if (typeof token === "function") {
-      realToken = getInjectableToken(token);
-    }
-    return new TestBindingBuilder(this, realToken);
-  }
-  bindValue(token, value) {
-    return this.bind(token).toValue(value);
-  }
-  bindClass(token, target) {
-    return this.bind(token).toClass(target);
-  }
-  /**
-   * Creates a new TestContainer instance with the same configuration.
-   * This is useful for creating isolated test containers.
-   * @returns A new TestContainer instance
-   */
-  createChild() {
-    return new _TestContainer(this.registry, this.logger, this.injectors);
-  }
-};
-_init = __decoratorStart(_a);
-_TestContainer = __decorateElement(_init, 0, "TestContainer", _TestContainer_decorators, _TestContainer);
-__runInitializers(_init, 1, _TestContainer);
-var TestContainer = _TestContainer;
-
-export { TestBindingBuilder, TestContainer };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+export { TestBindingBuilder, _TestContainer as TestContainer };