@navios/di 0.1.9 → 0.1.11

package/lib/index.js

@@ -1,795 +1,1027 @@
 "use strict";
-//#region rolldown:runtime
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.mts
+var index_exports = {};
+__export(index_exports, {
+  BoundInjectionToken: () => BoundInjectionToken,
+  ErrorsEnum: () => ErrorsEnum,
+  EventEmitter: () => EventEmitter,
+  FactoryInjectionToken: () => FactoryInjectionToken,
+  FactoryNotFound: () => FactoryNotFound,
+  FactoryTokenNotResolved: () => FactoryTokenNotResolved,
+  Injectable: () => Injectable,
+  InjectableScope: () => InjectableScope,
+  InjectableTokenMeta: () => InjectableTokenMeta,
+  InjectableType: () => InjectableType,
+  InjectionToken: () => InjectionToken,
+  InjectorsBase: () => InjectorsBase,
+  InstanceDestroying: () => InstanceDestroying,
+  InstanceExpired: () => InstanceExpired,
+  InstanceNotFound: () => InstanceNotFound,
+  ProxyServiceLocator: () => ProxyServiceLocator,
+  Registry: () => Registry,
+  ServiceLocator: () => ServiceLocator,
+  ServiceLocatorEventBus: () => ServiceLocatorEventBus,
+  ServiceLocatorInstanceHolderKind: () => ServiceLocatorInstanceHolderKind,
+  ServiceLocatorInstanceHolderStatus: () => ServiceLocatorInstanceHolderStatus,
+  ServiceLocatorManager: () => ServiceLocatorManager,
+  UnknownError: () => UnknownError,
+  getGlobalServiceLocator: () => getGlobalServiceLocator,
+  getInjectableToken: () => getInjectableToken,
+  getInjectors: () => getInjectors,
+  globalRegistry: () => globalRegistry,
+  inject: () => inject,
+  makeProxyServiceLocator: () => makeProxyServiceLocator,
+  provideServiceLocator: () => provideServiceLocator,
+  resolveService: () => resolveService,
+  syncInject: () => syncInject,
+  wrapSyncInit: () => wrapSyncInit
+});
+module.exports = __toCommonJS(index_exports);
 
-//#endregion
-require("zod");
+// src/decorators/injectable.decorator.mts
+var import_zod3 = require("zod");
 
-//#region src/enums/injectable-scope.enum.mts
-let InjectableScope = /* @__PURE__ */ function(InjectableScope$1) {
-	/**
-	* Singleton scope: The instance is created once and shared across the application.
-	*/
-	InjectableScope$1["Singleton"] = "Singleton";
-	/**
-	* Instance scope: A new instance is created for each injection.
-	*/
-	InjectableScope$1["Instance"] = "Instance";
-	return InjectableScope$1;
-}({});
+// src/enums/injectable-scope.enum.mts
+var InjectableScope = /* @__PURE__ */ ((InjectableScope3) => {
+  InjectableScope3["Singleton"] = "Singleton";
+  InjectableScope3["Instance"] = "Instance";
+  return InjectableScope3;
+})(InjectableScope || {});
 
-//#endregion
-//#region src/enums/injectable-type.enum.mts
-let InjectableType = /* @__PURE__ */ function(InjectableType$1) {
-	InjectableType$1["Class"] = "Class";
-	InjectableType$1["Factory"] = "Factory";
-	return InjectableType$1;
-}({});
+// src/enums/injectable-type.enum.mts
+var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
+  InjectableType2["Class"] = "Class";
+  InjectableType2["Factory"] = "Factory";
+  return InjectableType2;
+})(InjectableType || {});
 
-//#endregion
-//#region src/injection-token.mts
-const Optional = Symbol("Optional");
-const Required = Symbol("Required");
-var InjectionToken = class InjectionToken {
-	id = globalThis.crypto.randomUUID();
-	formattedName = null;
-	constructor(name, schema) {
-		this.name = name;
-		this.schema = schema;
-	}
-	static create(name, schema) {
-		return new InjectionToken(name, schema);
-	}
-	static bound(token, value) {
-		return new BoundInjectionToken(token, value);
-	}
-	static factory(token, factory) {
-		return new FactoryInjectionToken(token, factory);
-	}
-	static refineType(token) {
-		return token;
-	}
-	toString() {
-		if (this.formattedName) return this.formattedName;
-		const { name } = this;
-		if (typeof name === "function") {
-			const className = name.name;
-			this.formattedName = `${className}(${this.id})`;
-		} else if (typeof name === "symbol") this.formattedName = `${name.toString()}(${this.id})`;
-		else this.formattedName = `${name}(${this.id})`;
-		return this.formattedName;
-	}
+// src/injection-token.mts
+var import_zod = require("zod");
+var InjectionToken = class _InjectionToken {
+  constructor(name, schema) {
+    this.name = name;
+    this.schema = schema;
+  }
+  id = globalThis.crypto.randomUUID();
+  formattedName = null;
+  static create(name, schema) {
+    return new _InjectionToken(name, schema);
+  }
+  static bound(token, value) {
+    return new BoundInjectionToken(token, value);
+  }
+  static factory(token, factory) {
+    return new FactoryInjectionToken(token, factory);
+  }
+  static refineType(token) {
+    return token;
+  }
+  toString() {
+    if (this.formattedName) {
+      return this.formattedName;
+    }
+    const { name } = this;
+    if (typeof name === "function") {
+      const className = name.name;
+      this.formattedName = `${className}(${this.id})`;
+    } else if (typeof name === "symbol") {
+      this.formattedName = `${name.toString()}(${this.id})`;
+    } else {
+      this.formattedName = `${name}(${this.id})`;
+    }
+    return this.formattedName;
+  }
 };
 var BoundInjectionToken = class {
-	id;
-	name;
-	schema;
-	constructor(token, value) {
-		this.token = token;
-		this.value = value;
-		this.name = token.name;
-		this.id = token.id;
-		this.schema = token.schema;
-	}
-	toString() {
-		return this.token.toString();
-	}
+  constructor(token, value) {
+    this.token = token;
+    this.value = value;
+    this.name = token.name;
+    this.id = token.id;
+    this.schema = token.schema;
+  }
+  id;
+  name;
+  schema;
+  toString() {
+    return this.token.toString();
+  }
 };
 var FactoryInjectionToken = class {
-	value;
-	resolved = false;
-	id;
-	name;
-	schema;
-	constructor(token, factory) {
-		this.token = token;
-		this.factory = factory;
-		this.name = token.name;
-		this.id = token.id;
-		this.schema = token.schema;
-	}
-	async resolve() {
-		if (!this.value) {
-			this.value = await this.factory();
-			this.resolved = true;
-		}
-		return this.value;
-	}
-	toString() {
-		return this.token.toString();
-	}
+  constructor(token, factory) {
+    this.token = token;
+    this.factory = factory;
+    this.name = token.name;
+    this.id = token.id;
+    this.schema = token.schema;
+  }
+  value;
+  resolved = false;
+  id;
+  name;
+  schema;
+  async resolve() {
+    if (!this.value) {
+      this.value = await this.factory();
+      this.resolved = true;
+    }
+    return this.value;
+  }
+  toString() {
+    return this.token.toString();
+  }
 };
 
-//#endregion
-//#region src/registry.mts
+// src/registry.mts
+var import_zod2 = require("zod");
 var Registry = class {
-	factories = new Map();
-	constructor(parent) {
-		this.parent = parent;
-	}
-	has(token) {
-		if (this.factories.has(token.id)) return true;
-		if (this.parent) return this.parent.has(token);
-		return false;
-	}
-	get(token) {
-		const factory = this.factories.get(token.id);
-		if (!factory) {
-			if (this.parent) return this.parent.get(token);
-			throw new Error(`[Registry] No factory found for ${token.toString()}`);
-		}
-		return factory;
-	}
-	set(token, factory, scope) {
-		this.factories.set(token.id, {
-			factory,
-			scope,
-			originalToken: token
-		});
-	}
-	delete(token) {
-		this.factories.delete(token.id);
-	}
+  constructor(parent) {
+    this.parent = parent;
+  }
+  factories = /* @__PURE__ */ new Map();
+  has(token) {
+    if (this.factories.has(token.id)) {
+      return true;
+    }
+    if (this.parent) {
+      return this.parent.has(token);
+    }
+    return false;
+  }
+  get(token) {
+    const factory = this.factories.get(token.id);
+    if (!factory) {
+      if (this.parent) {
+        return this.parent.get(token);
+      }
+      throw new Error(`[Registry] No factory found for ${token.toString()}`);
+    }
+    return factory;
+  }
+  set(token, factory, scope) {
+    this.factories.set(token.id, { factory, scope, originalToken: token });
+  }
+  delete(token) {
+    this.factories.delete(token.id);
+  }
 };
-const globalRegistry = new Registry();
+var globalRegistry = new Registry();
 
-//#endregion
-//#region src/proxy-service-locator.mts
+// src/proxy-service-locator.mts
 var ProxyServiceLocator = class {
-	constructor(serviceLocator, ctx) {
-		this.serviceLocator = serviceLocator;
-		this.ctx = ctx;
-	}
-	getEventBus() {
-		return this.serviceLocator.getEventBus();
-	}
-	getInstance(token, args) {
-		return this.ctx.inject(token, args).then((instance) => {
-			return [void 0, instance];
-		}, (error) => {
-			return [error];
-		});
-	}
-	getOrThrowInstance(token, args) {
-		return this.ctx.inject(token, args);
-	}
-	getSyncInstance(token, args) {
-		return this.serviceLocator.getSyncInstance(token, args);
-	}
-	invalidate(service, round) {
-		return this.serviceLocator.invalidate(service, round);
-	}
-	ready() {
-		return this.serviceLocator.ready();
-	}
-	makeInstanceName(token, args) {
-		return this.serviceLocator.makeInstanceName(token, args);
-	}
+  constructor(serviceLocator, ctx) {
+    this.serviceLocator = serviceLocator;
+    this.ctx = ctx;
+  }
+  getEventBus() {
+    return this.serviceLocator.getEventBus();
+  }
+  // @ts-expect-error We don't need all the properties of the class
+  getInstance(token, args) {
+    return this.ctx.inject(token, args).then(
+      (instance) => {
+        return [void 0, instance];
+      },
+      (error) => {
+        return [error];
+      }
+    );
+  }
+  getOrThrowInstance(token, args) {
+    return this.ctx.inject(token, args);
+  }
+  getSyncInstance(token, args) {
+    return this.serviceLocator.getSyncInstance(token, args);
+  }
+  invalidate(service, round) {
+    return this.serviceLocator.invalidate(service, round);
+  }
+  ready() {
+    return this.serviceLocator.ready();
+  }
+  makeInstanceName(token, args) {
+    return this.serviceLocator.makeInstanceName(token, args);
+  }
 };
 function makeProxyServiceLocator(serviceLocator, ctx) {
-	return new ProxyServiceLocator(serviceLocator, ctx);
+  return new ProxyServiceLocator(serviceLocator, ctx);
 }
 
-//#endregion
-//#region src/symbols/injectable-token.mts
-const InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+// src/symbols/injectable-token.mts
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 
-//#endregion
-//#region src/utils/get-injectors.mts
-const InjectorsBase = new Map();
+// src/utils/get-injectors.mts
+var InjectorsBase = /* @__PURE__ */ new Map();
 function getInjectors({ baseLocator }) {
-	if (InjectorsBase.has(baseLocator)) return InjectorsBase.get(baseLocator);
-	let currentLocator = baseLocator;
-	function getServiceLocator() {
-		if (!currentLocator) throw new Error("[Injector] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.");
-		return currentLocator;
-	}
-	function provideServiceLocator$1(locator) {
-		const original = currentLocator;
-		currentLocator = locator;
-		return original;
-	}
-	function inject$1(token, args) {
-		const realToken = token[InjectableTokenMeta] ?? token;
-		return getServiceLocator().getOrThrowInstance(realToken, args);
-	}
-	let promiseCollector = null;
-	function wrapSyncInit$1(cb) {
-		return () => {
-			const promises = [];
-			const originalPromiseCollector = promiseCollector;
-			promiseCollector = (promise) => {
-				promises.push(promise);
-			};
-			const result = cb();
-			promiseCollector = originalPromiseCollector;
-			return [result, promises];
-		};
-	}
-	function syncInject$1(token, args) {
-		const realToken = token[InjectableTokenMeta] ?? token;
-		const instance = getServiceLocator().getSyncInstance(realToken, args);
-		if (!instance) if (promiseCollector) {
-			const promise = getServiceLocator().getInstance(realToken, args);
-			promiseCollector(promise);
-		} else throw new Error(`[Injector] Cannot initiate ${realToken.toString()}`);
-		return instance;
-	}
-	const injectors = {
-		inject: inject$1,
-		syncInject: syncInject$1,
-		wrapSyncInit: wrapSyncInit$1,
-		provideServiceLocator: provideServiceLocator$1
-	};
-	InjectorsBase.set(baseLocator, injectors);
-	return injectors;
+  if (InjectorsBase.has(baseLocator)) {
+    return InjectorsBase.get(baseLocator);
+  }
+  let currentLocator = baseLocator;
+  function getServiceLocator() {
+    if (!currentLocator) {
+      throw new Error(
+        "[Injector] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
+      );
+    }
+    return currentLocator;
+  }
+  function provideServiceLocator2(locator) {
+    const original = currentLocator;
+    currentLocator = locator;
+    return original;
+  }
+  function inject2(token, args) {
+    const realToken = token[InjectableTokenMeta] ?? token;
+    return getServiceLocator().getOrThrowInstance(realToken, args);
+  }
+  let promiseCollector = null;
+  function wrapSyncInit2(cb) {
+    return () => {
+      const promises = [];
+      const originalPromiseCollector = promiseCollector;
+      promiseCollector = (promise) => {
+        promises.push(promise);
+      };
+      const result = cb();
+      promiseCollector = originalPromiseCollector;
+      return [result, promises];
+    };
+  }
+  function syncInject2(token, args) {
+    const realToken = token[InjectableTokenMeta] ?? token;
+    const instance = getServiceLocator().getSyncInstance(realToken, args);
+    if (!instance) {
+      if (promiseCollector) {
+        const promise = getServiceLocator().getInstance(realToken, args);
+        promiseCollector(promise);
+      } else {
+        throw new Error(`[Injector] Cannot initiate ${realToken.toString()}`);
+      }
+      return new Proxy(
+        {},
+        {
+          get() {
+            throw new Error(
+              `[Injector] Trying to access ${realToken.toString()} before it's initialized, please use inject() instead of syncInject() or do not use the value outside of class methods`
+            );
+          }
+        }
+      );
+    }
+    return instance;
+  }
+  const injectors = {
+    inject: inject2,
+    syncInject: syncInject2,
+    wrapSyncInit: wrapSyncInit2,
+    provideServiceLocator: provideServiceLocator2
+  };
+  InjectorsBase.set(baseLocator, injectors);
+  return injectors;
 }
 
-//#endregion
-//#region src/utils/get-injectable-token.mts
+// src/utils/get-injectable-token.mts
 function getInjectableToken(target) {
-	const token = target[InjectableTokenMeta];
-	if (!token) throw new Error(`[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`);
-	return token;
+  const token = target[InjectableTokenMeta];
+  if (!token) {
+    throw new Error(
+      `[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`
+    );
+  }
+  return token;
 }
 
-//#endregion
-//#region src/resolve-service.mts
+// src/resolve-service.mts
 async function resolveService(ctx, target, args = []) {
-	const proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx);
-	const { wrapSyncInit: wrapSyncInit$1, provideServiceLocator: provideServiceLocator$1 } = getInjectors({ baseLocator: ctx.locator });
-	const tryLoad = wrapSyncInit$1(() => {
-		const original = provideServiceLocator$1(proxyServiceLocator);
-		let result = new target(...args);
-		provideServiceLocator$1(original);
-		return result;
-	});
-	let [instance, promises] = tryLoad();
-	if (promises.length > 0) {
-		await Promise.all(promises);
-		const newRes = tryLoad();
-		instance = newRes[0];
-		promises = newRes[1];
-	}
-	if (promises.length > 0) {
-		console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
+  const { wrapSyncInit: wrapSyncInit2, provideServiceLocator: provideServiceLocator2 } = getInjectors({
+    baseLocator: ctx.locator
+  });
+  const proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx);
+  const tryLoad = wrapSyncInit2(() => {
+    const original = provideServiceLocator2(proxyServiceLocator);
+    let result = new target(...args);
+    provideServiceLocator2(original);
+    return result;
+  });
+  let [instance, promises] = tryLoad();
+  if (promises.length > 0) {
+    await Promise.allSettled(promises);
+    const newRes = tryLoad();
+    instance = newRes[0];
+    promises = newRes[1];
+  }
+  if (promises.length > 0) {
+    console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
 
      One or more of the dependencies are registered as a InjectableScope.Instance and are used with syncInject.
 
      Please use inject instead of syncInject to load those dependencies.`);
-		throw new Error(`[ServiceLocator] Service ${target.name} cannot be instantiated.`);
-	}
-	return instance;
+    throw new Error(
+      `[ServiceLocator] Service ${target.name} cannot be instantiated.`
+    );
+  }
+  return instance;
 }
 
-//#endregion
-//#region src/decorators/injectable.decorator.mts
-function Injectable({ scope = InjectableScope.Singleton, type = InjectableType.Class, token, registry = globalRegistry } = {}) {
-	return (target, context) => {
-		if (context.kind !== "class") throw new Error("[ServiceLocator] @Injectable decorator can only be used on classes.");
-		let injectableToken = token ?? InjectionToken.create(target);
-		if (type === InjectableType.Class) registry.set(injectableToken, async (ctx, args) => resolveService(ctx, target, [args]), scope);
-		else if (type === InjectableType.Factory) registry.set(injectableToken, async (ctx, args) => {
-			const builder = await resolveService(ctx, target);
-			if (typeof builder.create !== "function") throw new Error(`[ServiceLocator] Factory ${target.name} does not implement the create method.`);
-			return builder.create(ctx, args);
-		}, scope);
-		target[InjectableTokenMeta] = injectableToken;
-		return target;
-	};
+// src/decorators/injectable.decorator.mts
+function Injectable({
+  scope = "Singleton" /* Singleton */,
+  type = "Class" /* Class */,
+  token,
+  registry = globalRegistry
+} = {}) {
+  return (target, context) => {
+    if (context.kind !== "class") {
+      throw new Error(
+        "[ServiceLocator] @Injectable decorator can only be used on classes."
+      );
+    }
+    let injectableToken = token ?? InjectionToken.create(target);
+    if (type === "Class" /* Class */) {
+      registry.set(
+        injectableToken,
+        async (ctx, args) => resolveService(ctx, target, [args]),
+        scope
+      );
+    } else if (type === "Factory" /* Factory */) {
+      registry.set(
+        injectableToken,
+        async (ctx, args) => {
+          const builder = await resolveService(ctx, target);
+          if (typeof builder.create !== "function") {
+            throw new Error(
+              `[ServiceLocator] Factory ${target.name} does not implement the create method.`
+            );
+          }
+          return builder.create(ctx, args);
+        },
+        scope
+      );
+    }
+    target[InjectableTokenMeta] = injectableToken;
+    return target;
+  };
 }
 
-//#endregion
-//#region src/errors/errors.enum.mts
-let ErrorsEnum = /* @__PURE__ */ function(ErrorsEnum$1) {
-	ErrorsEnum$1["InstanceExpired"] = "InstanceExpired";
-	ErrorsEnum$1["InstanceNotFound"] = "InstanceNotFound";
-	ErrorsEnum$1["InstanceDestroying"] = "InstanceDestroying";
-	ErrorsEnum$1["UnknownError"] = "UnknownError";
-	ErrorsEnum$1["FactoryNotFound"] = "FactoryNotFound";
-	ErrorsEnum$1["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
-	return ErrorsEnum$1;
-}({});
+// src/errors/errors.enum.mts
+var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
+  ErrorsEnum2["InstanceExpired"] = "InstanceExpired";
+  ErrorsEnum2["InstanceNotFound"] = "InstanceNotFound";
+  ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
+  ErrorsEnum2["UnknownError"] = "UnknownError";
+  ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
+  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
+  return ErrorsEnum2;
+})(ErrorsEnum || {});
 
-//#endregion
-//#region src/errors/factory-not-found.mts
+// src/errors/factory-not-found.mts
 var FactoryNotFound = class extends Error {
-	code = ErrorsEnum.FactoryNotFound;
-	constructor(name) {
-		super(`Factory ${name} not found`);
-		this.name = name;
-	}
+  constructor(name) {
+    super(`Factory ${name} not found`);
+    this.name = name;
+  }
+  code = "FactoryNotFound" /* FactoryNotFound */;
 };
 
-//#endregion
-//#region src/errors/factory-token-not-resolved.mts
+// src/errors/factory-token-not-resolved.mts
 var FactoryTokenNotResolved = class extends Error {
-	code = ErrorsEnum.FactoryTokenNotResolved;
-	constructor(name) {
-		super(`Factory token not resolved: ${name.toString()}`);
-	}
+  code = "FactoryTokenNotResolved" /* FactoryTokenNotResolved */;
+  constructor(name) {
+    super(`Factory token not resolved: ${name.toString()}`);
+  }
 };
 
-//#endregion
-//#region src/errors/instance-destroying.mts
+// src/errors/instance-destroying.mts
 var InstanceDestroying = class extends Error {
-	code = ErrorsEnum.InstanceDestroying;
-	constructor(name) {
-		super(`Instance ${name} destroying`);
-		this.name = name;
-	}
+  constructor(name) {
+    super(`Instance ${name} destroying`);
+    this.name = name;
+  }
+  code = "InstanceDestroying" /* InstanceDestroying */;
 };
 
-//#endregion
-//#region src/errors/instance-expired.mts
+// src/errors/instance-expired.mts
 var InstanceExpired = class extends Error {
-	code = ErrorsEnum.InstanceExpired;
-	constructor(name) {
-		super(`Instance ${name} expired`);
-		this.name = name;
-	}
+  constructor(name) {
+    super(`Instance ${name} expired`);
+    this.name = name;
+  }
+  code = "InstanceExpired" /* InstanceExpired */;
 };
 
-//#endregion
-//#region src/errors/instance-not-found.mts
+// src/errors/instance-not-found.mts
 var InstanceNotFound = class extends Error {
-	code = ErrorsEnum.InstanceNotFound;
-	constructor(name) {
-		super(`Instance ${name} not found`);
-		this.name = name;
-	}
+  constructor(name) {
+    super(`Instance ${name} not found`);
+    this.name = name;
+  }
+  code = "InstanceNotFound" /* InstanceNotFound */;
 };
 
-//#endregion
-//#region src/errors/unknown-error.mts
+// src/errors/unknown-error.mts
 var UnknownError = class extends Error {
-	code = ErrorsEnum.UnknownError;
-	parent;
-	constructor(message) {
-		if (message instanceof Error) {
-			super(message.message);
-			this.parent = message;
-			return;
-		}
-		super(message);
-	}
+  code = "UnknownError" /* UnknownError */;
+  parent;
+  constructor(message) {
+    if (message instanceof Error) {
+      super(message.message);
+      this.parent = message;
+      return;
+    }
+    super(message);
+  }
 };
 
-//#endregion
-//#region src/event-emitter.mts
+// src/interfaces/factory.interface.mts
+var import_zod4 = require("zod");
+
+// src/event-emitter.mts
 var EventEmitter = class {
-	listeners = new Map();
-	on(event, listener) {
-		if (!this.listeners.has(event)) this.listeners.set(event, 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)));
-	}
-	addChannel(ns, event, target) {
-		return this.on(event, (...args) => target.emit(ns, event, ...args));
-	}
+  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)));
+  }
+  addChannel(ns, event, target) {
+    return this.on(event, (...args) => target.emit(ns, event, ...args));
+  }
 };
 
-//#endregion
-//#region src/service-locator-event-bus.mts
+// src/service-locator-event-bus.mts
 var ServiceLocatorEventBus = class {
-	listeners = new Map();
-	constructor(logger = null) {
-		this.logger = logger;
-	}
-	on(ns, event, listener) {
-		this.logger?.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
-		if (!this.listeners.has(ns)) this.listeners.set(ns, new Map());
-		const nsEvents = this.listeners.get(ns);
-		if (!nsEvents.has(event)) nsEvents.set(event, new Set());
-		nsEvents.get(event).add(listener);
-		return () => {
-			nsEvents.get(event).delete(listener);
-			if (nsEvents.get(event)?.size === 0) nsEvents.delete(event);
-			if (nsEvents.size === 0) this.listeners.delete(ns);
-		};
-	}
-	async emit(key, event) {
-		if (!this.listeners.has(key)) return;
-		const events = this.listeners.get(key);
-		const preEvent = `pre:${event}`;
-		const postEvent = `post:${event}`;
-		this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
-		await Promise.allSettled([...events.get(preEvent) ?? []].map((listener) => listener(preEvent))).then((results) => {
-			results.filter((result) => result.status === "rejected").forEach((result) => {
-				this.logger?.warn(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`, result.reason);
-			});
-		});
-		this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
-		const res = await Promise.allSettled([...events.get(event) ?? []].map((listener) => listener(event))).then((results) => {
-			const res$1 = results.filter((result) => result.status === "rejected").map((result) => {
-				this.logger?.warn(`[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`, result.reason);
-				return result;
-			});
-			if (res$1.length > 0) return Promise.reject(res$1);
-			return results;
-		});
-		this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`);
-		await Promise.allSettled([...events.get(postEvent) ?? []].map((listener) => listener(postEvent))).then((results) => {
-			results.filter((result) => result.status === "rejected").forEach((result) => {
-				this.logger?.warn(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`, result.reason);
-			});
-		});
-		return res;
-	}
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  listeners = /* @__PURE__ */ new Map();
+  on(ns, event, listener) {
+    this.logger?.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
+    if (!this.listeners.has(ns)) {
+      this.listeners.set(ns, /* @__PURE__ */ new Map());
+    }
+    const nsEvents = this.listeners.get(ns);
+    if (!nsEvents.has(event)) {
+      nsEvents.set(event, /* @__PURE__ */ new Set());
+    }
+    nsEvents.get(event).add(listener);
+    return () => {
+      nsEvents.get(event).delete(listener);
+      if (nsEvents.get(event)?.size === 0) {
+        nsEvents.delete(event);
+      }
+      if (nsEvents.size === 0) {
+        this.listeners.delete(ns);
+      }
+    };
+  }
+  async emit(key, event) {
+    if (!this.listeners.has(key)) {
+      return;
+    }
+    const events = this.listeners.get(key);
+    const preEvent = `pre:${event}`;
+    const postEvent = `post:${event}`;
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
+    await Promise.allSettled(
+      [...events.get(preEvent) ?? []].map((listener) => listener(preEvent))
+    ).then((results) => {
+      results.filter((result) => result.status === "rejected").forEach((result) => {
+        this.logger?.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
+          result.reason
+        );
+      });
+    });
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
+    const res = await Promise.allSettled(
+      [...events.get(event) ?? []].map((listener) => listener(event))
+    ).then((results) => {
+      const res2 = results.filter((result) => result.status === "rejected").map((result) => {
+        this.logger?.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
+          result.reason
+        );
+        return result;
+      });
+      if (res2.length > 0) {
+        return Promise.reject(res2);
+      }
+      return results;
+    });
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`);
+    await Promise.allSettled(
+      [...events.get(postEvent) ?? []].map((listener) => listener(postEvent))
+    ).then((results) => {
+      results.filter((result) => result.status === "rejected").forEach((result) => {
+        this.logger?.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
+          result.reason
+        );
+      });
+    });
+    return res;
+  }
 };
 
-//#endregion
-//#region src/service-locator-instance-holder.mts
-let ServiceLocatorInstanceHolderKind = /* @__PURE__ */ function(ServiceLocatorInstanceHolderKind$1) {
-	ServiceLocatorInstanceHolderKind$1["Instance"] = "instance";
-	ServiceLocatorInstanceHolderKind$1["Factory"] = "factory";
-	ServiceLocatorInstanceHolderKind$1["AbstractFactory"] = "abstractFactory";
-	return ServiceLocatorInstanceHolderKind$1;
-}({});
-let ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ function(ServiceLocatorInstanceHolderStatus$1) {
-	ServiceLocatorInstanceHolderStatus$1["Created"] = "created";
-	ServiceLocatorInstanceHolderStatus$1["Creating"] = "creating";
-	ServiceLocatorInstanceHolderStatus$1["Destroying"] = "destroying";
-	return ServiceLocatorInstanceHolderStatus$1;
-}({});
+// src/service-locator-instance-holder.mts
+var ServiceLocatorInstanceHolderKind = /* @__PURE__ */ ((ServiceLocatorInstanceHolderKind2) => {
+  ServiceLocatorInstanceHolderKind2["Instance"] = "instance";
+  ServiceLocatorInstanceHolderKind2["Factory"] = "factory";
+  ServiceLocatorInstanceHolderKind2["AbstractFactory"] = "abstractFactory";
+  return ServiceLocatorInstanceHolderKind2;
+})(ServiceLocatorInstanceHolderKind || {});
+var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
+  ServiceLocatorInstanceHolderStatus2["Created"] = "created";
+  ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
+  ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
+  return ServiceLocatorInstanceHolderStatus2;
+})(ServiceLocatorInstanceHolderStatus || {});
 
-//#endregion
-//#region src/service-locator-manager.mts
+// src/service-locator-manager.mts
 var ServiceLocatorManager = class {
-	instancesHolders = new Map();
-	constructor(logger = null) {
-		this.logger = logger;
-	}
-	get(name) {
-		const holder = this.instancesHolders.get(name);
-		if (holder) {
-			if (holder.ttl !== Infinity) {
-				const now = Date.now();
-				if (now - holder.createdAt > holder.ttl) {
-					this.logger?.log(`[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`);
-					return [new InstanceExpired(holder.name), holder];
-				}
-			} else if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) {
-				this.logger?.log(`[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`);
-				return [new InstanceDestroying(holder.name), holder];
-			}
-			return [void 0, holder];
-		} else {
-			this.logger?.log(`[ServiceLocatorManager]#getInstanceHolder() Instance ${name} not found`);
-			return [new InstanceNotFound(name)];
-		}
-	}
-	set(name, holder) {
-		this.instancesHolders.set(name, holder);
-	}
-	has(name) {
-		const [error, holder] = this.get(name);
-		if (!error) return [void 0, true];
-		if ([ErrorsEnum.InstanceExpired, ErrorsEnum.InstanceDestroying].includes(error.code)) return [error];
-		return [void 0, !!holder];
-	}
-	delete(name) {
-		return this.instancesHolders.delete(name);
-	}
-	filter(predicate) {
-		return new Map([...this.instancesHolders].filter(([key, value]) => predicate(value, key)));
-	}
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  instancesHolders = /* @__PURE__ */ new Map();
+  get(name) {
+    const holder = this.instancesHolders.get(name);
+    if (holder) {
+      if (holder.ttl !== Infinity) {
+        const now = Date.now();
+        if (now - holder.createdAt > holder.ttl) {
+          this.logger?.log(
+            `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`
+          );
+          return [new InstanceExpired(holder.name), holder];
+        }
+      } else if (holder.status === "destroying" /* Destroying */) {
+        this.logger?.log(
+          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`
+        );
+        return [new InstanceDestroying(holder.name), holder];
+      }
+      return [void 0, holder];
+    } else {
+      this.logger?.log(
+        `[ServiceLocatorManager]#getInstanceHolder() Instance ${name} not found`
+      );
+      return [new InstanceNotFound(name)];
+    }
+  }
+  set(name, holder) {
+    this.instancesHolders.set(name, holder);
+  }
+  has(name) {
+    const [error, holder] = this.get(name);
+    if (!error) {
+      return [void 0, true];
+    }
+    if (["InstanceExpired" /* InstanceExpired */, "InstanceDestroying" /* InstanceDestroying */].includes(
+      error.code
+    )) {
+      return [error];
+    }
+    return [void 0, !!holder];
+  }
+  delete(name) {
+    return this.instancesHolders.delete(name);
+  }
+  filter(predicate) {
+    return new Map(
+      [...this.instancesHolders].filter(
+        ([key, value]) => predicate(value, key)
+      )
+    );
+  }
 };
 
-//#endregion
-//#region src/service-locator.mts
+// src/service-locator.mts
 var ServiceLocator = class {
-	eventBus;
-	manager;
-	constructor(registry = globalRegistry, logger = null) {
-		this.registry = registry;
-		this.logger = logger;
-		this.eventBus = new ServiceLocatorEventBus(logger);
-		this.manager = new ServiceLocatorManager(logger);
-	}
-	getEventBus() {
-		return this.eventBus;
-	}
-	storeInstance(instance, token, args) {
-		const instanceName = this.getInstanceIdentifier(token, args);
-		this.manager.set(instanceName, {
-			name: instanceName,
-			instance,
-			status: ServiceLocatorInstanceHolderStatus.Created,
-			kind: ServiceLocatorInstanceHolderKind.Instance,
-			createdAt: Date.now(),
-			ttl: Infinity,
-			deps: [],
-			destroyListeners: [],
-			effects: [],
-			destroyPromise: null,
-			creationPromise: null
-		});
-		this.notifyListeners(instanceName);
-	}
-	removeInstance(token, args) {
-		const instanceName = this.getInstanceIdentifier(token, args);
-		return this.invalidate(instanceName);
-	}
-	resolveTokenArgs(token, args) {
-		let realArgs = args;
-		if (token instanceof BoundInjectionToken) realArgs = token.value;
-		else if (token instanceof FactoryInjectionToken) if (token.resolved) realArgs = token.value;
-		else return [new FactoryTokenNotResolved(token.name)];
-		if (!token.schema) return [void 0, realArgs];
-		const validatedArgs = token.schema?.safeParse(realArgs);
-		if (validatedArgs && !validatedArgs.success) {
-			this.logger?.error(`[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`, validatedArgs.error);
-			return [new UnknownError(validatedArgs.error)];
-		}
-		return [void 0, validatedArgs?.data];
-	}
-	getInstanceIdentifier(token, args) {
-		const [err, realArgs] = this.resolveTokenArgs(token, args);
-		if (err) throw err;
-		return this.makeInstanceName(token, realArgs);
-	}
-	async getInstance(token, args) {
-		const [err, realArgs] = this.resolveTokenArgs(token, args);
-		if (err instanceof UnknownError) return [err];
-		else if (err instanceof FactoryTokenNotResolved && token instanceof FactoryInjectionToken) {
-			await token.resolve();
-			return this.getInstance(token, args);
-		}
-		const instanceName = this.makeInstanceName(token, realArgs);
-		const [error, holder] = this.manager.get(instanceName);
-		if (!error) {
-			if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) return holder.creationPromise;
-			else if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) return [new UnknownError(ErrorsEnum.InstanceDestroying)];
-			return [void 0, holder.instance];
-		}
-		switch (error.code) {
-			case ErrorsEnum.InstanceDestroying:
-				this.logger?.log(`[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`);
-				await holder?.destroyPromise;
-				return this.getInstance(token, args);
-			case ErrorsEnum.InstanceExpired:
-				this.logger?.log(`[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`);
-				await this.invalidate(instanceName);
-				return this.getInstance(token, args);
-			case ErrorsEnum.InstanceNotFound: break;
-			default: return [error];
-		}
-		return this.createInstance(instanceName, token, realArgs);
-	}
-	async getOrThrowInstance(token, args) {
-		const [error, instance] = await this.getInstance(token, args);
-		if (error) throw error;
-		return instance;
-	}
-	notifyListeners(name, event = "create") {
-		this.logger?.log(`[ServiceLocator]#notifyListeners() Notifying listeners for ${name} with event ${event}`);
-		return this.eventBus.emit(name, event);
-	}
-	async createInstance(instanceName, token, args) {
-		this.logger?.log(`[ServiceLocator]#createInstance() Creating instance for ${instanceName}`);
-		let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
-		if (this.registry.has(realToken)) return this.resolveInstance(instanceName, realToken, args);
-		else return [new FactoryNotFound(realToken.name.toString())];
-	}
-	async resolveInstance(instanceName, token, args) {
-		this.logger?.log(`[ServiceLocator]#resolveInstance(): Creating instance for ${instanceName} from abstract factory`);
-		const ctx = this.createFactoryContext(instanceName);
-		let { factory, scope } = this.registry.get(token);
-		const holder = {
-			name: instanceName,
-			instance: null,
-			status: ServiceLocatorInstanceHolderStatus.Creating,
-			kind: ServiceLocatorInstanceHolderKind.AbstractFactory,
-			creationPromise: factory(ctx, args).then(async (instance) => {
-				holder.instance = instance;
-				holder.status = ServiceLocatorInstanceHolderStatus.Created;
-				holder.deps = ctx.getDependencies();
-				holder.destroyListeners = ctx.getDestroyListeners();
-				holder.ttl = ctx.getTtl();
-				if (holder.deps.length > 0) {
-					this.logger?.log(`[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(", ")}`);
-					holder.deps.forEach((dependency) => {
-						holder.destroyListeners.push(this.eventBus.on(dependency, "destroy", () => this.invalidate(instanceName)));
-					});
-				}
-				if (holder.ttl === 0 || scope === InjectableScope.Instance) await this.invalidate(instanceName);
-				await this.notifyListeners(instanceName);
-				return [void 0, instance];
-			}).catch((error) => {
-				this.logger?.error(`[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`, error);
-				return [new UnknownError(error)];
-			}),
-			effects: [],
-			deps: [],
-			destroyListeners: [],
-			createdAt: Date.now(),
-			ttl: Infinity
-		};
-		if (scope === InjectableScope.Singleton) this.manager.set(instanceName, holder);
-		return holder.creationPromise;
-	}
-	createFactoryContext(instanceName) {
-		const dependencies = new Set();
-		const destroyListeners = new Set();
-		const self = this;
-		function invalidate(name = instanceName) {
-			return self.invalidate(name);
-		}
-		function addEffect(listener) {
-			destroyListeners.add(listener);
-		}
-		let ttl = Infinity;
-		function setTtl(value) {
-			ttl = value;
-		}
-		function getTtl() {
-			return ttl;
-		}
-		function on(key, event, listener) {
-			destroyListeners.add(self.eventBus.on(key, event, listener));
-		}
-		return {
-			async inject(token, args) {
-				let injectionToken = token;
-				if (typeof token === "function") injectionToken = getInjectableToken(token);
-				if (injectionToken instanceof InjectionToken) {
-					const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
-					const instanceName$1 = self.makeInstanceName(token, validatedArgs);
-					dependencies.add(instanceName$1);
-					return self.getOrThrowInstance(injectionToken, args);
-				}
-				throw new Error(`[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`);
-			},
-			invalidate,
-			on,
-			getDependencies: () => Array.from(dependencies),
-			addEffect,
-			getDestroyListeners: () => Array.from(destroyListeners),
-			setTtl,
-			getTtl,
-			locator: self
-		};
-	}
-	getSyncInstance(token, args) {
-		const [err, realArgs] = this.resolveTokenArgs(token, args);
-		if (err) return null;
-		const instanceName = this.makeInstanceName(token, realArgs);
-		const [error, holder] = this.manager.get(instanceName);
-		if (error) return null;
-		return holder.instance;
-	}
-	invalidate(service, round = 1) {
-		this.logger?.log(`[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`);
-		const toInvalidate = this.manager.filter((holder) => holder.name === service || holder.deps.includes(service));
-		const promises = [];
-		for (const [key, holder] of toInvalidate.entries()) {
-			if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) {
-				this.logger?.trace(`[ServiceLocator]#invalidate(): ${key} is already being destroyed`);
-				promises.push(holder.destroyPromise);
-				continue;
-			}
-			if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) {
-				this.logger?.trace(`[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`);
-				promises.push(holder.creationPromise?.then(() => {
-					if (round > 3) {
-						this.logger?.error(`[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`);
-						return;
-					}
-					return this.invalidate(key, round + 1);
-				}));
-				continue;
-			}
-			holder.status = ServiceLocatorInstanceHolderStatus.Destroying;
-			this.logger?.log(`[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`);
-			holder.destroyPromise = Promise.all(holder.destroyListeners.map((listener) => listener())).then(async () => {
-				this.manager.delete(key);
-				await this.notifyListeners(key, "destroy");
-			});
-			promises.push(holder.destroyPromise);
-		}
-		return Promise.all(promises);
-	}
-	async ready() {
-		return Promise.all(Array.from(this.manager.filter(() => true)).map(([, holder]) => {
-			if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) return holder.creationPromise?.then(() => null);
-			if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) return holder.destroyPromise.then(() => null);
-			return Promise.resolve(null);
-		})).then(() => null);
-	}
-	makeInstanceName(token, args) {
-		const formattedArgs = args ? ":" + JSON.stringify(args, (_, value) => {
-			if (typeof value === "function") return `function:${value.name}(${value.length})`;
-			if (typeof value === "symbol") return value.toString();
-			return value;
-		}).replaceAll(/"/g, "").replaceAll(/:/g, "=").replaceAll(/,/g, "|") : "";
-		return `${token.toString()}${formattedArgs}`;
-	}
+  constructor(registry = globalRegistry, logger = null) {
+    this.registry = registry;
+    this.logger = logger;
+    this.eventBus = new ServiceLocatorEventBus(logger);
+    this.manager = new ServiceLocatorManager(logger);
+  }
+  eventBus;
+  manager;
+  getEventBus() {
+    return this.eventBus;
+  }
+  storeInstance(instance, token, args) {
+    const instanceName = this.getInstanceIdentifier(token, args);
+    this.manager.set(instanceName, {
+      name: instanceName,
+      instance,
+      status: "created" /* Created */,
+      kind: "instance" /* Instance */,
+      createdAt: Date.now(),
+      ttl: Infinity,
+      deps: [],
+      destroyListeners: [],
+      effects: [],
+      destroyPromise: null,
+      creationPromise: null
+    });
+    this.notifyListeners(instanceName);
+  }
+  removeInstance(token, args) {
+    const instanceName = this.getInstanceIdentifier(token, args);
+    return this.invalidate(instanceName);
+  }
+  resolveTokenArgs(token, args) {
+    let realArgs = args;
+    if (token instanceof BoundInjectionToken) {
+      realArgs = token.value;
+    } else if (token instanceof FactoryInjectionToken) {
+      if (token.resolved) {
+        realArgs = token.value;
+      } else {
+        return [new FactoryTokenNotResolved(token.name)];
+      }
+    }
+    if (!token.schema) {
+      return [void 0, realArgs];
+    }
+    const validatedArgs = token.schema?.safeParse(realArgs);
+    if (validatedArgs && !validatedArgs.success) {
+      this.logger?.error(
+        `[ServiceLocator]#resolveTokenArgs(): Error validating args for ${token.name.toString()}`,
+        validatedArgs.error
+      );
+      return [new UnknownError(validatedArgs.error)];
+    }
+    return [void 0, validatedArgs?.data];
+  }
+  getInstanceIdentifier(token, args) {
+    const [err, realArgs] = this.resolveTokenArgs(
+      token,
+      args
+    );
+    if (err) {
+      throw err;
+    }
+    return this.makeInstanceName(token, realArgs);
+  }
+  async getInstance(token, args) {
+    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    if (err instanceof UnknownError) {
+      return [err];
+    } else if (err instanceof FactoryTokenNotResolved && token instanceof FactoryInjectionToken) {
+      this.logger?.log(
+        `[ServiceLocator]#getInstance() Factory token not resolved, resolving it`
+      );
+      await token.resolve();
+      return this.getInstance(token);
+    }
+    const instanceName = this.makeInstanceName(token, realArgs);
+    const [error, holder] = this.manager.get(instanceName);
+    if (!error) {
+      if (holder.status === "creating" /* Creating */) {
+        return holder.creationPromise;
+      } else if (holder.status === "destroying" /* Destroying */) {
+        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
+      }
+      return [void 0, holder.instance];
+    }
+    switch (error.code) {
+      case "InstanceDestroying" /* InstanceDestroying */:
+        this.logger?.log(
+          `[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`
+        );
+        await holder?.destroyPromise;
+        return this.getInstance(token, args);
+      case "InstanceExpired" /* InstanceExpired */:
+        this.logger?.log(
+          `[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`
+        );
+        await this.invalidate(instanceName);
+        return this.getInstance(token, args);
+      case "InstanceNotFound" /* InstanceNotFound */:
+        break;
+      default:
+        return [error];
+    }
+    return this.createInstance(instanceName, token, realArgs);
+  }
+  async getOrThrowInstance(token, args) {
+    const [error, instance] = await this.getInstance(token, args);
+    if (error) {
+      throw error;
+    }
+    return instance;
+  }
+  notifyListeners(name, event = "create") {
+    this.logger?.log(
+      `[ServiceLocator]#notifyListeners() Notifying listeners for ${name} with event ${event}`
+    );
+    return this.eventBus.emit(name, event);
+  }
+  async createInstance(instanceName, token, args) {
+    this.logger?.log(
+      `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`
+    );
+    let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
+    if (this.registry.has(realToken)) {
+      return this.resolveInstance(instanceName, realToken, args);
+    } else {
+      return [new FactoryNotFound(realToken.name.toString())];
+    }
+  }
+  resolveInstance(instanceName, token, args) {
+    this.logger?.log(
+      `[ServiceLocator]#resolveInstance(): Creating instance for ${instanceName} from abstract factory`
+    );
+    const ctx = this.createFactoryContext(instanceName);
+    let { factory, scope } = this.registry.get(token);
+    const holder = {
+      name: instanceName,
+      instance: null,
+      status: "creating" /* Creating */,
+      kind: "abstractFactory" /* AbstractFactory */,
+      // @ts-expect-error TS2322 This is correct type
+      creationPromise: factory(ctx, args).then(async (instance) => {
+        holder.instance = instance;
+        holder.status = "created" /* Created */;
+        holder.deps = ctx.getDependencies();
+        holder.destroyListeners = ctx.getDestroyListeners();
+        holder.ttl = ctx.getTtl();
+        if (holder.deps.length > 0) {
+          this.logger?.log(
+            `[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(
+              ", "
+            )}`
+          );
+          holder.deps.forEach((dependency) => {
+            holder.destroyListeners.push(
+              this.eventBus.on(
+                dependency,
+                "destroy",
+                () => this.invalidate(instanceName)
+              )
+            );
+          });
+        }
+        if (holder.ttl === 0 || scope === "Instance" /* Instance */) {
+          await this.invalidate(instanceName);
+        }
+        await this.notifyListeners(instanceName);
+        return [void 0, instance];
+      }).catch((error) => {
+        this.logger?.error(
+          `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
+          error
+        );
+        return [new UnknownError(error)];
+      }),
+      effects: [],
+      deps: [],
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl: Infinity
+    };
+    if (scope === "Singleton" /* Singleton */) {
+      this.logger?.debug(
+        `[ServiceLocator]#resolveInstance(): Setting instance for ${instanceName}`
+      );
+      this.manager.set(instanceName, holder);
+    }
+    return holder.creationPromise;
+  }
+  createFactoryContext(instanceName) {
+    const dependencies = /* @__PURE__ */ new Set();
+    const destroyListeners = /* @__PURE__ */ new Set();
+    const self = this;
+    function invalidate(name = instanceName) {
+      return self.invalidate(name);
+    }
+    function addEffect(listener) {
+      destroyListeners.add(listener);
+    }
+    let ttl = Infinity;
+    function setTtl(value) {
+      ttl = value;
+    }
+    function getTtl() {
+      return ttl;
+    }
+    function on(key, event, listener) {
+      destroyListeners.add(self.eventBus.on(key, event, listener));
+    }
+    return {
+      // @ts-expect-error This is correct type
+      async inject(token, args) {
+        let injectionToken = token;
+        if (typeof token === "function") {
+          injectionToken = getInjectableToken(token);
+        }
+        if (injectionToken) {
+          const [err, validatedArgs] = self.resolveTokenArgs(
+            injectionToken,
+            args
+          );
+          if (err) {
+            throw err;
+          }
+          const instanceName2 = self.makeInstanceName(token, validatedArgs);
+          dependencies.add(instanceName2);
+          return self.getOrThrowInstance(injectionToken, args);
+        }
+        throw new Error(
+          `[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`
+        );
+      },
+      invalidate,
+      on,
+      getDependencies: () => Array.from(dependencies),
+      addEffect,
+      getDestroyListeners: () => Array.from(destroyListeners),
+      setTtl,
+      getTtl,
+      locator: self
+    };
+  }
+  getSyncInstance(token, args) {
+    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    if (err) {
+      return null;
+    }
+    const instanceName = this.makeInstanceName(token, realArgs);
+    const [error, holder] = this.manager.get(instanceName);
+    if (error) {
+      return null;
+    }
+    return holder.instance;
+  }
+  invalidate(service, round = 1) {
+    this.logger?.log(
+      `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`
+    );
+    const toInvalidate = this.manager.filter(
+      (holder) => holder.name === service || holder.deps.includes(service)
+    );
+    const promises = [];
+    for (const [key, holder] of toInvalidate.entries()) {
+      if (holder.status === "destroying" /* Destroying */) {
+        this.logger?.trace(
+          `[ServiceLocator]#invalidate(): ${key} is already being destroyed`
+        );
+        promises.push(holder.destroyPromise);
+        continue;
+      }
+      if (holder.status === "creating" /* Creating */) {
+        this.logger?.trace(
+          `[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`
+        );
+        promises.push(
+          holder.creationPromise?.then(() => {
+            if (round > 3) {
+              this.logger?.error(
+                `[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`
+              );
+              return;
+            }
+            return this.invalidate(key, round + 1);
+          })
+        );
+        continue;
+      }
+      holder.status = "destroying" /* Destroying */;
+      this.logger?.log(
+        `[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`
+      );
+      holder.destroyPromise = Promise.all(
+        holder.destroyListeners.map((listener) => listener())
+      ).then(async () => {
+        this.manager.delete(key);
+        await this.notifyListeners(key, "destroy");
+      });
+      promises.push(holder.destroyPromise);
+    }
+    return Promise.all(promises);
+  }
+  async ready() {
+    return Promise.all(
+      Array.from(this.manager.filter(() => true)).map(([, holder]) => {
+        if (holder.status === "creating" /* Creating */) {
+          return holder.creationPromise?.then(() => null);
+        }
+        if (holder.status === "destroying" /* Destroying */) {
+          return holder.destroyPromise.then(() => null);
+        }
+        return Promise.resolve(null);
+      })
+    ).then(() => null);
+  }
+  makeInstanceName(token, args) {
+    const formattedArgs = args ? ":" + Object.entries(args ?? {}).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => {
+      if (typeof value === "function") {
+        return `${key}=fn_${value.name}(${value.length})`;
+      }
+      if (typeof value === "symbol") {
+        return `${key}=${value.toString()}`;
+      }
+      return `${key}=${JSON.stringify(value).slice(0, 40)}`;
+    }).join(",").replaceAll(/"/g, "").replaceAll(/:/g, "=") : "";
+    return `${token.toString()}${formattedArgs}`;
+  }
 };
 
-//#endregion
-//#region src/injector.mts
-const globalServiceLocator = new ServiceLocator();
+// src/injector.mts
+var globalServiceLocator = new ServiceLocator(globalRegistry);
 function getGlobalServiceLocator() {
-	if (!globalServiceLocator) throw new Error("[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.");
-	return globalServiceLocator;
+  if (!globalServiceLocator) {
+    throw new Error(
+      "[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
+    );
+  }
+  return globalServiceLocator;
 }
-const values = getInjectors({ baseLocator: globalServiceLocator });
-const inject = values.inject;
-const syncInject = values.syncInject;
-const wrapSyncInit = values.wrapSyncInit;
-const provideServiceLocator = values.provideServiceLocator;
-
-//#endregion
-exports.BoundInjectionToken = BoundInjectionToken;
-exports.ErrorsEnum = ErrorsEnum;
-exports.EventEmitter = EventEmitter;
-exports.FactoryInjectionToken = FactoryInjectionToken;
-exports.FactoryNotFound = FactoryNotFound;
-exports.FactoryTokenNotResolved = FactoryTokenNotResolved;
-exports.Injectable = Injectable;
-exports.InjectableScope = InjectableScope;
-exports.InjectableTokenMeta = InjectableTokenMeta;
-exports.InjectableType = InjectableType;
-exports.InjectionToken = InjectionToken;
-exports.InjectorsBase = InjectorsBase;
-exports.InstanceDestroying = InstanceDestroying;
-exports.InstanceExpired = InstanceExpired;
-exports.InstanceNotFound = InstanceNotFound;
-exports.Optional = Optional;
-exports.ProxyServiceLocator = ProxyServiceLocator;
-exports.Registry = Registry;
-exports.Required = Required;
-exports.ServiceLocator = ServiceLocator;
-exports.ServiceLocatorEventBus = ServiceLocatorEventBus;
-exports.ServiceLocatorInstanceHolderKind = ServiceLocatorInstanceHolderKind;
-exports.ServiceLocatorInstanceHolderStatus = ServiceLocatorInstanceHolderStatus;
-exports.ServiceLocatorManager = ServiceLocatorManager;
-exports.UnknownError = UnknownError;
-exports.getGlobalServiceLocator = getGlobalServiceLocator;
-exports.getInjectableToken = getInjectableToken;
-exports.getInjectors = getInjectors;
-exports.globalRegistry = globalRegistry;
-exports.inject = inject;
-exports.makeProxyServiceLocator = makeProxyServiceLocator;
-exports.provideServiceLocator = provideServiceLocator;
-exports.resolveService = resolveService;
-exports.syncInject = syncInject;
-exports.wrapSyncInit = wrapSyncInit;
+var values = getInjectors({
+  baseLocator: globalServiceLocator
+});
+var inject = values.inject;
+var syncInject = values.syncInject;
+var wrapSyncInit = values.wrapSyncInit;
+var provideServiceLocator = values.provideServiceLocator;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoundInjectionToken,
+  ErrorsEnum,
+  EventEmitter,
+  FactoryInjectionToken,
+  FactoryNotFound,
+  FactoryTokenNotResolved,
+  Injectable,
+  InjectableScope,
+  InjectableTokenMeta,
+  InjectableType,
+  InjectionToken,
+  InjectorsBase,
+  InstanceDestroying,
+  InstanceExpired,
+  InstanceNotFound,
+  ProxyServiceLocator,
+  Registry,
+  ServiceLocator,
+  ServiceLocatorEventBus,
+  ServiceLocatorInstanceHolderKind,
+  ServiceLocatorInstanceHolderStatus,
+  ServiceLocatorManager,
+  UnknownError,
+  getGlobalServiceLocator,
+  getInjectableToken,
+  getInjectors,
+  globalRegistry,
+  inject,
+  makeProxyServiceLocator,
+  provideServiceLocator,
+  resolveService,
+  syncInject,
+  wrapSyncInit
+});
+//# sourceMappingURL=index.js.map